From 3b9b7b6edf77819f6b9670b0857d8757e95e9fb0 Mon Sep 17 00:00:00 2001 From: Tanner Gooding Date: Mon, 6 Aug 2018 08:08:06 -0700 Subject: Regenerating the templated x86 HWIntrinsic tests. --- .../JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/AddSubtract.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/AddSubtract.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/And.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/And.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/AndNot.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/AndNot.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/BlendVariable.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/BlendVariable.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Ceiling.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Ceiling.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Divide.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Divide.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/DuplicateEvenIndexed.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/DuplicateEvenIndexed.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/DuplicateOddIndexed.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.Byte.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.Int16.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.Int32.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.Int64.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.SByte.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtendToVector256.UInt64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Byte.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Byte.20.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Byte.52.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Int32.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Int32.22.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Int32.6.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Int64.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Int64.19.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.Int64.3.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx/Extract.UInt16.11.cs | 30 ++++++++++++++++++++ .../X86/Avx/Extract.UInt16.27.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx/Extract.UInt32.22.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.UInt32.6.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx/Extract.UInt64.19.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Extract.UInt64.3.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.Byte.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.Double.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.Int16.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.Int32.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.Int64.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.SByte.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.Single.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.UInt16.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.UInt32.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx/ExtractVector128.UInt64.1.Store.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.Byte.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.Int16.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.Int32.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.Int64.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.SByte.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Avx/GetLowerHalf.UInt64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Byte.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Byte.20.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Byte.52.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int16.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int16.11.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int16.27.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int32.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int32.22.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int32.6.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int64.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int64.19.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.Int64.3.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.SByte.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.SByte.20.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.SByte.52.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt16.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt16.11.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt16.27.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt32.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt32.22.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt32.6.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt64.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt64.19.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Insert.UInt64.3.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.Byte.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.Double.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.Int16.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.Int32.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.Int64.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.SByte.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.Single.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.UInt16.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.UInt32.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx/InsertVector128.UInt64.1.Load.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Multiply.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Multiply.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Permute.Double.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Permute.Double.2.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Permute.Single.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Permute.Single.2.cs | 30 ++++++++++++++++++++ .../X86/Avx/PermuteVar.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/PermuteVar.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundCurrentDirection.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundCurrentDirection.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToNearestInteger.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToNearestInteger.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToNegativeInfinity.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToNegativeInfinity.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToPositiveInfinity.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToPositiveInfinity.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToZero.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx/RoundToZero.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Subtract.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx/Subtract.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Avx/TestNotZAndNotC.Byte.cs | 33 +++++++++++++++++++++- .../X86/Avx/TestNotZAndNotC.Int16.cs | 33 +++++++++++++++++++++- .../X86/Avx/TestNotZAndNotC.Int32.cs | 33 +++++++++++++++++++++- .../X86/Avx/TestNotZAndNotC.Int64.cs | 33 +++++++++++++++++++++- .../X86/Avx/TestNotZAndNotC.SByte.cs | 33 +++++++++++++++++++++- .../X86/Avx/TestNotZAndNotC.UInt16.cs | 33 +++++++++++++++++++++- .../X86/Avx/TestNotZAndNotC.UInt32.cs | 33 +++++++++++++++++++++- .../X86/Avx/TestNotZAndNotC.UInt64.cs | 33 +++++++++++++++++++++- .../JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/AlignRight.SByte.228.cs | 30 ++++++++++++++++++++ .../X86/Avx2/AlignRight.SByte.250.cs | 30 ++++++++++++++++++++ .../X86/Avx2/AlignRight.SByte.27.cs | 30 ++++++++++++++++++++ .../X86/Avx2/AlignRight.SByte.5.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Average.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Average.UInt16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BlendVariable.Byte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BlendVariable.SByte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.Byte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.Int16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.Int32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.Int64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.SByte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector128.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.Byte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.Int16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.Int32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.Int64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.SByte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.Single.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/BroadcastScalarToVector256.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.Byte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.Int16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.Int32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.Int64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.SByte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareEqual.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareGreaterThan.Int16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareGreaterThan.Int32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareGreaterThan.Int64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/CompareGreaterThan.SByte.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ConvertToDouble.Double.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ConvertToInt32.Int32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ConvertToUInt32.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Byte.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Byte.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Int16.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Int32.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Int64.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.SByte.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.SByte.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.UInt16.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.UInt32.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.UInt64.1.Store.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ExtractVector128.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Byte.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Byte.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Int16.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Int32.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Int64.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.SByte.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.SByte.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.UInt16.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.UInt32.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.UInt64.1.Load.cs | 30 ++++++++++++++++++++ .../X86/Avx2/InsertVector128.UInt64.1.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs | 30 ++++++++++++++++++++ .../src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/Permute2x128.Int32.2.cs | 30 ++++++++++++++++++++ .../X86/Avx2/Permute2x128.Int64.2.cs | 30 ++++++++++++++++++++ .../X86/Avx2/Permute2x128.UInt32.2.cs | 30 ++++++++++++++++++++ .../X86/Avx2/Permute2x128.UInt64.2.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.Int16.16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.Int32.32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.Int64.64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.UInt16.16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.UInt32.32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical.UInt64.64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightArithmetic.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightArithmetic.Int16.16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightArithmetic.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightArithmetic.Int32.32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.Int16.16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.Int32.32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.Int64.64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.UInt16.16.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.UInt32.32.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical.UInt64.64.cs | 30 ++++++++++++++++++++ .../X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftRightLogical128BitLane.Int16.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftRightLogical128BitLane.Int32.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftRightLogical128BitLane.Int64.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftRightLogical128BitLane.SByte.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftRightLogical128BitLane.UInt16.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftRightLogical128BitLane.UInt32.1.cs | 30 ++++++++++++++++++++ .../Avx2/ShiftRightLogical128BitLane.UInt64.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.Int32.2.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.Int32.4.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.Int32.85.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.UInt32.2.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.UInt32.4.cs | 30 ++++++++++++++++++++ .../X86/Avx2_Vector128/Blend.UInt32.85.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs | 18 ++++++++++++ .../HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs | 18 ++++++++++++ .../X86/Bmi1/ExtractLowestSetBit.UInt32.cs | 18 ++++++++++++ .../X86/Bmi1/ExtractLowestSetBit.UInt64.cs | 18 ++++++++++++ .../X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs | 18 ++++++++++++ .../X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs | 18 ++++++++++++ .../X86/Bmi1/ResetLowestSetBit.UInt32.cs | 18 ++++++++++++ .../X86/Bmi1/ResetLowestSetBit.UInt64.cs | 18 ++++++++++++ .../X86/Bmi1/TrailingZeroCount.UInt32.cs | 18 ++++++++++++ .../X86/Bmi1/TrailingZeroCount.UInt64.cs | 18 ++++++++++++ .../X86/Bmi2/ParallelBitDeposit.UInt32.cs | 18 ++++++++++++ .../X86/Bmi2/ParallelBitDeposit.UInt64.cs | 18 ++++++++++++ .../X86/Bmi2/ParallelBitExtract.UInt32.cs | 18 ++++++++++++ .../X86/Bmi2/ParallelBitExtract.UInt64.cs | 18 ++++++++++++ .../X86/Fma_Vector128/MultiplyAdd.Double.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector128/MultiplyAdd.Single.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector128/MultiplyAddNegated.Double.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector128/MultiplyAddNegated.Single.cs | 30 ++++++++++++++++++++ .../MultiplyAddNegatedScalar.Double.cs | 30 ++++++++++++++++++++ .../MultiplyAddNegatedScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector128/MultiplyAddScalar.Double.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector128/MultiplyAddScalar.Single.cs | 30 ++++++++++++++++++++ .../Fma_Vector128/MultiplyAddSubtract.Double.cs | 30 ++++++++++++++++++++ .../Fma_Vector128/MultiplyAddSubtract.Single.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector128/MultiplySubtract.Double.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector128/MultiplySubtract.Single.cs | 30 ++++++++++++++++++++ .../Fma_Vector128/MultiplySubtractAdd.Double.cs | 30 ++++++++++++++++++++ .../Fma_Vector128/MultiplySubtractAdd.Single.cs | 30 ++++++++++++++++++++ .../MultiplySubtractNegated.Double.cs | 30 ++++++++++++++++++++ .../MultiplySubtractNegated.Single.cs | 30 ++++++++++++++++++++ .../MultiplySubtractNegatedScalar.Double.cs | 30 ++++++++++++++++++++ .../MultiplySubtractNegatedScalar.Single.cs | 30 ++++++++++++++++++++ .../Fma_Vector128/MultiplySubtractScalar.Double.cs | 30 ++++++++++++++++++++ .../Fma_Vector128/MultiplySubtractScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector256/MultiplyAdd.Double.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector256/MultiplyAdd.Single.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector256/MultiplyAddNegated.Double.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector256/MultiplyAddNegated.Single.cs | 30 ++++++++++++++++++++ .../Fma_Vector256/MultiplyAddSubtract.Double.cs | 30 ++++++++++++++++++++ .../Fma_Vector256/MultiplyAddSubtract.Single.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector256/MultiplySubtract.Double.cs | 30 ++++++++++++++++++++ .../X86/Fma_Vector256/MultiplySubtract.Single.cs | 30 ++++++++++++++++++++ .../Fma_Vector256/MultiplySubtractAdd.Double.cs | 30 ++++++++++++++++++++ .../Fma_Vector256/MultiplySubtractAdd.Single.cs | 30 ++++++++++++++++++++ .../MultiplySubtractNegated.Double.cs | 30 ++++++++++++++++++++ .../MultiplySubtractNegated.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse/AddScalar.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse/And.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse/AndNot.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareEqual.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareEqualOrderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareEqualScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareEqualUnorderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareGreaterThan.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareGreaterThanOrEqual.Single.cs | 30 ++++++++++++++++++++ ...mpareGreaterThanOrEqualOrderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../Sse/CompareGreaterThanOrEqualScalar.Single.cs | 30 ++++++++++++++++++++ ...areGreaterThanOrEqualUnorderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../Sse/CompareGreaterThanOrderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareGreaterThanScalar.Single.cs | 30 ++++++++++++++++++++ .../CompareGreaterThanUnorderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareLessThan.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareLessThanOrEqual.Single.cs | 30 ++++++++++++++++++++ .../CompareLessThanOrEqualOrderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareLessThanOrEqualScalar.Single.cs | 30 ++++++++++++++++++++ ...ompareLessThanOrEqualUnorderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../Sse/CompareLessThanOrderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareLessThanScalar.Single.cs | 30 ++++++++++++++++++++ .../Sse/CompareLessThanUnorderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotEqual.Single.cs | 30 ++++++++++++++++++++ .../Sse/CompareNotEqualOrderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotEqualScalar.Single.cs | 30 ++++++++++++++++++++ .../Sse/CompareNotEqualUnorderedScalar.Boolean.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotGreaterThan.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotGreaterThanOrEqual.Single.cs | 30 ++++++++++++++++++++ .../CompareNotGreaterThanOrEqualScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotGreaterThanScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotLessThan.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotLessThanOrEqual.Single.cs | 30 ++++++++++++++++++++ .../Sse/CompareNotLessThanOrEqualScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareNotLessThanScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareOrdered.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareOrderedScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareUnordered.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/CompareUnorderedScalar.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse/Divide.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/DivideScalar.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse/MinScalar.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse/Multiply.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/MultiplyScalar.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse/Subtract.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse/SubtractScalar.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Sse2/AddSaturate.Byte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/AddSaturate.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/AddSaturate.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/AddSaturate.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/AddScalar.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Average.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Average.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareEqual.Byte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareEqual.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareEqual.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareEqual.Int32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareEqual.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareEqual.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareEqual.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareGreaterThan.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareGreaterThan.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareGreaterThan.Int32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareGreaterThan.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareGreaterThanOrEqual.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareLessThan.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareLessThan.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareLessThan.Int32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareLessThan.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareLessThanOrEqual.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareNotEqual.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareNotGreaterThan.Double.cs | 30 ++++++++++++++++++++ .../Sse2/CompareNotGreaterThanOrEqual.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareNotLessThan.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareNotLessThanOrEqual.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareOrdered.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/CompareUnordered.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Divide.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/DivideScalar.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/Extract.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/Extract.UInt16.129.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/Insert.Int16.129.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/Insert.UInt16.129.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/MaxScalar.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/MinScalar.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Multiply.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse2/MultiplyScalar.Double.cs | 30 ++++++++++++++++++++ .../src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Sse2/SetAllVector128.Byte.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.Double.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.Int16.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.Int32.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.Int64.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.SByte.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.UInt16.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.UInt32.cs | 18 ++++++++++++ .../X86/Sse2/SetAllVector128.UInt64.cs | 18 ++++++++++++ .../X86/Sse2/ShiftLeftLogical.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.Int16.16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.Int32.32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.Int64.64.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.UInt16.16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.UInt32.32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical.UInt64.64.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightArithmetic.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightArithmetic.Int16.16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightArithmetic.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightArithmetic.Int32.32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.Int16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.Int16.16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.Int32.32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.Int64.64.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.UInt16.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.UInt16.16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.UInt32.32.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical.UInt64.64.cs | 30 ++++++++++++++++++++ .../X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftRightLogical128BitLane.Int16.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftRightLogical128BitLane.Int32.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftRightLogical128BitLane.Int64.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftRightLogical128BitLane.SByte.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftRightLogical128BitLane.UInt16.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftRightLogical128BitLane.UInt32.1.cs | 30 ++++++++++++++++++++ .../Sse2/ShiftRightLogical128BitLane.UInt64.1.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Sse2/SubtractSaturate.Byte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/SubtractSaturate.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/SubtractSaturate.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse2/SubtractSaturate.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Sse2/SubtractScalar.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Sse3/AddSubtract.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse3/AddSubtract.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse3/HorizontalAdd.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse3/HorizontalAdd.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse3/HorizontalSubtract.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse3/HorizontalSubtract.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/BlendVariable.Byte.cs | 30 ++++++++++++++++++++ .../X86/Sse41/BlendVariable.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/BlendVariable.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse41/BlendVariable.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/CeilingScalar.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/CeilingScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/CompareEqual.Int64.cs | 30 ++++++++++++++++++++ .../X86/Sse41/CompareEqual.UInt64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.Byte.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.Int32.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.Int64.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.Single.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.Single.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.UInt32.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Extract.UInt64.129.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Floor.Double.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Floor.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/FloorScalar.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/FloorScalar.Single.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Byte.129.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Int32.129.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Int64.129.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.SByte.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.0.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.128.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.16.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.192.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.2.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.32.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.4.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.48.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.64.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.Single.8.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.UInt32.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.UInt32.129.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.UInt64.1.cs | 30 ++++++++++++++++++++ .../X86/Sse41/Insert.UInt64.129.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Sse41/MultiplyLow.Int32.cs | 30 ++++++++++++++++++++ .../X86/Sse41/PackUnsignedSaturate.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundCurrentDirection.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundCurrentDirection.Single.cs | 30 ++++++++++++++++++++ .../Sse41/RoundCurrentDirectionScalar.Double.cs | 30 ++++++++++++++++++++ .../Sse41/RoundCurrentDirectionScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToNearestInteger.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToNearestInteger.Single.cs | 30 ++++++++++++++++++++ .../Sse41/RoundToNearestIntegerScalar.Double.cs | 30 ++++++++++++++++++++ .../Sse41/RoundToNearestIntegerScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToNegativeInfinity.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToNegativeInfinity.Single.cs | 30 ++++++++++++++++++++ .../Sse41/RoundToNegativeInfinityScalar.Double.cs | 30 ++++++++++++++++++++ .../Sse41/RoundToNegativeInfinityScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToPositiveInfinity.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToPositiveInfinity.Single.cs | 30 ++++++++++++++++++++ .../Sse41/RoundToPositiveInfinityScalar.Double.cs | 30 ++++++++++++++++++++ .../Sse41/RoundToPositiveInfinityScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToZero.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToZero.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToZeroScalar.Double.cs | 30 ++++++++++++++++++++ .../X86/Sse41/RoundToZeroScalar.Single.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.Byte.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.Int32.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.Int64.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllOnes.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.Byte.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.Int16.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.Int32.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.Int64.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.SByte.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.UInt16.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestAllZeros.UInt64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestC.Int16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestC.Int32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestC.Int64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestC.SByte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Sse41/TestMixOnesZeros.Byte.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestMixOnesZeros.Int16.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestMixOnesZeros.Int32.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestMixOnesZeros.Int64.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestMixOnesZeros.SByte.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestMixOnesZeros.UInt16.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestMixOnesZeros.UInt32.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestMixOnesZeros.UInt64.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.Byte.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.Int16.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.Int32.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.Int64.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.SByte.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.UInt16.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.UInt32.cs | 33 +++++++++++++++++++++- .../X86/Sse41/TestNotZAndNotC.UInt64.cs | 33 +++++++++++++++++++++- .../JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs | 30 ++++++++++++++++++++ .../X86/Sse42/CompareGreaterThan.Int64.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/HorizontalAdd.Int16.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/HorizontalAdd.Int32.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/HorizontalAddSaturate.Int16.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/HorizontalSubtract.Int16.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/HorizontalSubtract.Int32.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/HorizontalSubtractSaturate.Int16.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/MultiplyAddAdjacent.Int16.cs | 30 ++++++++++++++++++++ .../X86/Ssse3/MultiplyHighRoundScale.Int16.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs | 30 ++++++++++++++++++++ .../HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs | 30 ++++++++++++++++++++ .../JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs | 30 ++++++++++++++++++++ 772 files changed, 22932 insertions(+), 24 deletions(-) (limited to 'tests') diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs index 972a8ef86c..24fb9fb3e8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Add( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Add( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddDouble(); var result = Avx.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs index a57ea12acd..01f2db0874 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Add.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Add( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Add( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSingle(); var result = Avx.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs index 6112638e54..758d91f618 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.AddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.AddSubtract( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.AddSubtract( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.AddSubtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.AddSubtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.AddSubtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.AddSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.AddSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.AddSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.AddSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSubtractDouble(); var result = Avx.AddSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.AddSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.AddSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs index 8b2d0011f7..c6eb8db6f6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AddSubtract.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.AddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.AddSubtract( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.AddSubtract( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.AddSubtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.AddSubtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.AddSubtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.AddSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.AddSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.AddSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.AddSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSubtractSingle(); var result = Avx.AddSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.AddSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.AddSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs index ffbe1d4920..f207fe2c8c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.And( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.And( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndDouble(); var result = Avx.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs index 2d7c88e772..29798455d1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/And.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.And( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.And( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndSingle(); var result = Avx.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs index 1e5f154332..bc5b294c94 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.AndNot( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.AndNot( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotDouble(); var result = Avx.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs index 02db725fa9..987e1a52e4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/AndNot.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.AndNot( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.AndNot( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotSingle(); var result = Avx.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs index 76f1d38b74..fa14505457 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.BlendVariable( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.BlendVariable( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableDouble(); var result = Avx.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs index 48650b0213..fafd645235 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/BlendVariable.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.BlendVariable( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.BlendVariable( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableSingle(); var result = Avx.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs index 851f0f2385..8c311e3f0e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Ceiling( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Ceiling( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Ceiling( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Ceiling), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Ceiling), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Ceiling), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Ceiling( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Ceiling(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.Ceiling(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.Ceiling(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__CeilingDouble(); var result = Avx.Ceiling(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Ceiling(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Ceiling(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs index 7ac905a576..1462f4f5a3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Ceiling.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Ceiling( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Ceiling( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Ceiling( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Ceiling), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Ceiling), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Ceiling), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Ceiling( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Ceiling(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.Ceiling(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.Ceiling(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__CeilingSingle(); var result = Avx.Ceiling(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Ceiling(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Ceiling(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs index ce073940a2..72d2491a2b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Divide( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Divide( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Divide( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Divide), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Divide), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Divide), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Divide( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Divide(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Divide(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Divide(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__DivideDouble(); var result = Avx.Divide(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Divide(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Divide(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs index 53e2607dbd..71be742281 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Divide.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Divide( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Divide( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Divide( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Divide), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Divide), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Divide), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Divide( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Divide(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Divide(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Divide(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__DivideSingle(); var result = Avx.Divide(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Divide(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Divide(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs index 700ea19679..8108e7f5dc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.DuplicateEvenIndexed( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.DuplicateEvenIndexed( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.DuplicateEvenIndexed( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateEvenIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateEvenIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateEvenIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.DuplicateEvenIndexed( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.DuplicateEvenIndexed(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.DuplicateEvenIndexed(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.DuplicateEvenIndexed(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__DuplicateEvenIndexedDouble(); var result = Avx.DuplicateEvenIndexed(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.DuplicateEvenIndexed(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.DuplicateEvenIndexed(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs index a309934b2d..58114a75ee 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateEvenIndexed.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.DuplicateEvenIndexed( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.DuplicateEvenIndexed( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.DuplicateEvenIndexed( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateEvenIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateEvenIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateEvenIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.DuplicateEvenIndexed( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.DuplicateEvenIndexed(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.DuplicateEvenIndexed(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.DuplicateEvenIndexed(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__DuplicateEvenIndexedSingle(); var result = Avx.DuplicateEvenIndexed(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.DuplicateEvenIndexed(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.DuplicateEvenIndexed(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs index eb6664964d..1f550d8972 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/DuplicateOddIndexed.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.DuplicateOddIndexed( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.DuplicateOddIndexed( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.DuplicateOddIndexed( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateOddIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateOddIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.DuplicateOddIndexed), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.DuplicateOddIndexed( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.DuplicateOddIndexed(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.DuplicateOddIndexed(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.DuplicateOddIndexed(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__DuplicateOddIndexedSingle(); var result = Avx.DuplicateOddIndexed(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.DuplicateOddIndexed(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.DuplicateOddIndexed(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Byte.cs index 7b265c0a34..ad5ac0eb29 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Byte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256Byte(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Double.cs index 83659d35b1..d115c52a0c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256Double(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int16.cs index e4e2705911..65d7f9d775 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256Int16(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int32.cs index 107a4299fa..74232c909c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256Int32(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int64.cs index 91e0f9928c..1349b7b063 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Int64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256Int64(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.SByte.cs index c496972c85..06e8051425 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.SByte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256SByte(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Single.cs index 50965ba4ad..d2e242200f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256Single(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt16.cs index c49e13f73b..ccc6051a28 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256UInt16(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt32.cs index bd33fa2267..4dbc0d941c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256UInt32(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt64.cs index 9bce14f15a..d7ed56ca3a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtendToVector256.UInt64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.ExtendToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.ExtendToVector256( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.ExtendToVector256( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.ExtendToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.ExtendToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.ExtendToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.ExtendToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__ExtendToVector256UInt64(); var result = Avx.ExtendToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.ExtendToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.ExtendToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.1.cs index 6c2387ca0a..37f50eb022 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractByte1(); var result = Avx.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.20.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.20.cs index d1a819e203..c9a957e391 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.20.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.20.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 20 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), 20 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), 20 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 20 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 20); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 20); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 20); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractByte20(); var result = Avx.Extract(test._fld, 20); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 20); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 20); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.52.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.52.cs index d332160519..14d09dc283 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.52.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Byte.52.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 52 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), 52 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), 52 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 52 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 52); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 52); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 52); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractByte52(); var result = Avx.Extract(test._fld, 52); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 52); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 52); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.1.cs index a37574b071..5559b8cb54 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt321(); var result = Avx.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.22.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.22.cs index cb4eba3a3c..6d917ea304 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.22.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.22.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 22 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 22 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 22 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 22 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 22); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 22); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 22); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt3222(); var result = Avx.Extract(test._fld, 22); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 22); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 22); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.6.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.6.cs index 0a3a7bce36..f51c3598bc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.6.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int32.6.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 6 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 6 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 6 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 6 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 6); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 6); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 6); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt326(); var result = Avx.Extract(test._fld, 6); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 6); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 6); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.1.cs index 4bf0fd76c6..1d0a09810a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt641(); var result = Avx.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.19.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.19.cs index 73554b1190..8152bc7ea8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.19.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.19.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 19 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 19 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 19 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 19 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 19); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 19); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 19); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt6419(); var result = Avx.Extract(test._fld, 19); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 19); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 19); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.3.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.3.cs index 7ba12d4666..d3492f9afd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.3.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.Int64.3.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 3 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 3 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 3 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 3 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 3); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 3); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 3); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt643(); var result = Avx.Extract(test._fld, 3); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 3); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.1.cs index 09a08afb86..8d5332ec15 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt161(); var result = Avx.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.11.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.11.cs index f45adf707a..272480f0ed 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.11.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.11.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 11 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 11 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 11 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 11 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 11); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 11); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 11); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt1611(); var result = Avx.Extract(test._fld, 11); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 11); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 11); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.27.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.27.cs index d740847c0c..028739e066 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.27.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt16.27.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 27 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 27 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 27 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 27 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 27); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 27); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 27); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt1627(); var result = Avx.Extract(test._fld, 27); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 27); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 27); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.1.cs index 2f49523dde..0d32239595 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt321(); var result = Avx.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.22.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.22.cs index adc57a37ce..39a63c6be3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.22.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.22.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 22 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 22 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 22 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 22 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 22); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 22); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 22); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt3222(); var result = Avx.Extract(test._fld, 22); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 22); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 22); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.6.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.6.cs index 586ee49356..c35fa11ff0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.6.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt32.6.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 6 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 6 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 6 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 6 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 6); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 6); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 6); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt326(); var result = Avx.Extract(test._fld, 6); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 6); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 6); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.1.cs index f0d9414b2e..4fb3405ecb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt641(); var result = Avx.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.19.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.19.cs index 8fbfdeca39..53653ca28b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.19.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.19.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 19 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 19 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 19 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 19 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 19); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 19); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 19); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt6419(); var result = Avx.Extract(test._fld, 19); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 19); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 19); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.3.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.3.cs index 612ce0f5fa..44dfc71255 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.3.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Extract.UInt64.3.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 3 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Extract( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 3 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Extract( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 3 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Extract), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Extract( _clsVar, 3 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Extract(firstOp, 3); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 3); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Extract(firstOp, 3); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt643(); var result = Avx.Extract(test._fld, 3); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Extract(_fld, 3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Extract(test._fld, 3); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs index 65f7081166..7c2ea2696f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Byte.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (Byte*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (Byte*)_dataTable.outArrayPtr, Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (Byte*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Byte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Byte*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Byte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Byte*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Byte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Byte*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (Byte*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((Byte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Byte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Byte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Byte1(); Avx.ExtractVector128((Byte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((Byte*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((Byte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs index c4201241bd..950b731622 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Double.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (Double*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (Double*)_dataTable.outArrayPtr, Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (Double*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Double*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Double*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Double*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Double*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Double*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Double*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (Double*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((Double*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Double*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Double*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Double1(); Avx.ExtractVector128((Double*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((Double*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((Double*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs index 16c678707d..3fe4b176da 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int16.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (Int16*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (Int16*)_dataTable.outArrayPtr, Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (Int16*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int16*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int16*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int16*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (Int16*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((Int16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Int16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Int16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Int161(); Avx.ExtractVector128((Int16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((Int16*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((Int16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs index 2aaa8fb154..db9e2c18ae 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int32.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (Int32*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (Int32*)_dataTable.outArrayPtr, Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (Int32*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int32*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int32*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int32*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (Int32*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((Int32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Int32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Int32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Int321(); Avx.ExtractVector128((Int32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((Int32*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((Int32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs index cd638e5042..d84e7cf5fb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Int64.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (Int64*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (Int64*)_dataTable.outArrayPtr, Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (Int64*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int64*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int64*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Int64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int64*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (Int64*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((Int64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Int64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Int64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Int641(); Avx.ExtractVector128((Int64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((Int64*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((Int64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs index 2015c58c63..1b1080166f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.SByte.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (SByte*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (SByte*)_dataTable.outArrayPtr, Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (SByte*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(SByte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(SByte*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(SByte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(SByte*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(SByte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(SByte*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (SByte*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((SByte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((SByte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((SByte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128SByte1(); Avx.ExtractVector128((SByte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((SByte*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((SByte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs index e646609af7..4d947ae9d8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.Single.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (Single*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (Single*)_dataTable.outArrayPtr, Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (Single*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Single*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Single*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Single*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Single*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(Single*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Single*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (Single*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((Single*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Single*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((Single*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Single1(); Avx.ExtractVector128((Single*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((Single*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((Single*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs index f5a4a799f6..fcefc3be07 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt16.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt16*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt16*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt16*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((UInt16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((UInt16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((UInt16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128UInt161(); Avx.ExtractVector128((UInt16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((UInt16*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((UInt16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs index a9bef3e3d3..d0512c51f2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt32.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt32*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt32*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt32*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((UInt32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((UInt32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((UInt32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128UInt321(); Avx.ExtractVector128((UInt32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((UInt32*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((UInt32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs index 757a186b5c..da6cda2693 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/ExtractVector128.UInt64.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt64*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt64*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx).GetMethod(nameof(Avx.ExtractVector128), new Type[] { typeof(UInt64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt64*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx.ExtractVector128((UInt64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((UInt64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); Avx.ExtractVector128((UInt64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128UInt641(); Avx.ExtractVector128((UInt64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx.ExtractVector128((UInt64*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx.ExtractVector128((UInt64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs index 8f0097e77e..4cc14cc316 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Floor( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Floor( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Floor( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Floor), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Floor), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Floor), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Floor( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Floor(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.Floor(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.Floor(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__FloorDouble(); var result = Avx.Floor(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Floor(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Floor(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs index 2c379a3a29..7058b02fc8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Floor.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Floor( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Floor( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Floor( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Floor), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Floor), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Floor), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Floor( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Floor(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.Floor(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.Floor(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__FloorSingle(); var result = Avx.Floor(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Floor(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Floor(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Byte.cs index 927f006ad2..c0f5a4092a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Byte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfByte(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Double.cs index c3d9f414c9..de39986bcd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfDouble(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int16.cs index e2f86caa06..d876afcfab 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfInt16(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int32.cs index 83377a28cd..f8a24fc9be 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfInt32(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int64.cs index 364e770c45..e0d621c94e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Int64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfInt64(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.SByte.cs index a1f7326144..44c474f13e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.SByte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfSByte(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Single.cs index cf6f1a91e4..1aea5cab09 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfSingle(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt16.cs index f93d05b3ee..ebffd58f3b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfUInt16(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt32.cs index 851dc8b217..4c1ab2b51b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfUInt32(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt64.cs index a18396cd32..1a87f3317d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/GetLowerHalf.UInt64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.GetLowerHalf( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.GetLowerHalf( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.GetLowerHalf( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.GetLowerHalf)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.GetLowerHalf( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.GetLowerHalf(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.GetLowerHalf(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__GetLowerHalfUInt64(); var result = Avx.GetLowerHalf(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.GetLowerHalf(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.GetLowerHalf(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.1.cs index d601dd09fe..e5d096ef4d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (byte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (byte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (byte)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (byte)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (byte)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertByte1(); var result = Avx.Insert(test._fld, (byte)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (byte)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (byte)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.20.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.20.cs index 3fa2534661..5afd44c8b0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.20.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.20.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (byte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (byte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (byte)2, 20); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (byte)2, 20); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (byte)2, 20); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertByte20(); var result = Avx.Insert(test._fld, (byte)2, 20); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (byte)2, 20); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (byte)2, 20); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.52.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.52.cs index 9a93755002..0effba91b5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.52.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Byte.52.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (byte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (byte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (byte)2, 52); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (byte)2, 52); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (byte)2, 52); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertByte52(); var result = Avx.Insert(test._fld, (byte)2, 52); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (byte)2, 52); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (byte)2, 52); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.1.cs index fe87bbd2fe..9b09b57388 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (short)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (short)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (short)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (short)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (short)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt161(); var result = Avx.Insert(test._fld, (short)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (short)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (short)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.11.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.11.cs index 21bce9abfa..fb0c813d1d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.11.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.11.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (short)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (short)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (short)2, 11); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (short)2, 11); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (short)2, 11); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt1611(); var result = Avx.Insert(test._fld, (short)2, 11); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (short)2, 11); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (short)2, 11); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.27.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.27.cs index 7992f378f5..6d57bc0f56 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.27.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int16.27.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (short)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (short)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (short)2, 27); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (short)2, 27); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (short)2, 27); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt1627(); var result = Avx.Insert(test._fld, (short)2, 27); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (short)2, 27); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (short)2, 27); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.1.cs index 6d53338a82..102419b266 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (int)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (int)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (int)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (int)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (int)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt321(); var result = Avx.Insert(test._fld, (int)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (int)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (int)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.22.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.22.cs index daa608e155..187d723006 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.22.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.22.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (int)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (int)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (int)2, 22); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (int)2, 22); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (int)2, 22); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt3222(); var result = Avx.Insert(test._fld, (int)2, 22); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (int)2, 22); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (int)2, 22); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.6.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.6.cs index 2a3c17fd37..81e8ec3dc3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.6.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int32.6.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (int)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (int)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (int)2, 6); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (int)2, 6); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (int)2, 6); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt326(); var result = Avx.Insert(test._fld, (int)2, 6); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (int)2, 6); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (int)2, 6); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.1.cs index 1449daf2c9..328c3678ee 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (long)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (long)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (long)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (long)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (long)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt641(); var result = Avx.Insert(test._fld, (long)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (long)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (long)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.19.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.19.cs index e7abb3ecba..5c1adcd80a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.19.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.19.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (long)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (long)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (long)2, 19); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (long)2, 19); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (long)2, 19); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt6419(); var result = Avx.Insert(test._fld, (long)2, 19); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (long)2, 19); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (long)2, 19); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.3.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.3.cs index 09ce2ffcf4..91a37fb68b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.3.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.Int64.3.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (long)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (long)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (long)2, 3); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (long)2, 3); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (long)2, 3); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt643(); var result = Avx.Insert(test._fld, (long)2, 3); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (long)2, 3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (long)2, 3); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.1.cs index e7db91c91c..f65259daa7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (sbyte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (sbyte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (sbyte)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (sbyte)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (sbyte)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertSByte1(); var result = Avx.Insert(test._fld, (sbyte)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (sbyte)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (sbyte)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.20.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.20.cs index 95739da9a3..d9cb013623 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.20.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.20.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (sbyte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (sbyte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (sbyte)2, 20); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (sbyte)2, 20); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (sbyte)2, 20); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertSByte20(); var result = Avx.Insert(test._fld, (sbyte)2, 20); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (sbyte)2, 20); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (sbyte)2, 20); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.52.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.52.cs index ddcc84842c..8f60eb664e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.52.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.SByte.52.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (sbyte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (sbyte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (sbyte)2, 52); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (sbyte)2, 52); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (sbyte)2, 52); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertSByte52(); var result = Avx.Insert(test._fld, (sbyte)2, 52); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (sbyte)2, 52); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (sbyte)2, 52); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.1.cs index f1cef27ec6..e838a244c1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ushort)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (ushort)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (ushort)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ushort)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ushort)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt161(); var result = Avx.Insert(test._fld, (ushort)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (ushort)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (ushort)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.11.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.11.cs index 3ce7bd4bad..be465e3861 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.11.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.11.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ushort)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (ushort)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (ushort)2, 11); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ushort)2, 11); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ushort)2, 11); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt1611(); var result = Avx.Insert(test._fld, (ushort)2, 11); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (ushort)2, 11); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (ushort)2, 11); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.27.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.27.cs index b0a915e593..f62b1d0d6c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.27.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt16.27.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ushort)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (ushort)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (ushort)2, 27); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ushort)2, 27); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ushort)2, 27); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt1627(); var result = Avx.Insert(test._fld, (ushort)2, 27); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (ushort)2, 27); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (ushort)2, 27); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.1.cs index e36743cfec..e96390ab5b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (uint)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (uint)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (uint)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (uint)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (uint)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt321(); var result = Avx.Insert(test._fld, (uint)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (uint)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (uint)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.22.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.22.cs index 29d2258348..0249357c4a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.22.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.22.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (uint)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (uint)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (uint)2, 22); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (uint)2, 22); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (uint)2, 22); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt3222(); var result = Avx.Insert(test._fld, (uint)2, 22); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (uint)2, 22); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (uint)2, 22); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.6.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.6.cs index 088c3f27e3..3309912a14 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.6.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt32.6.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (uint)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (uint)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (uint)2, 6); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (uint)2, 6); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (uint)2, 6); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt326(); var result = Avx.Insert(test._fld, (uint)2, 6); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (uint)2, 6); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (uint)2, 6); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.1.cs index ad30d4a6b8..80a24dcfff 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ulong)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (ulong)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (ulong)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ulong)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ulong)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt641(); var result = Avx.Insert(test._fld, (ulong)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (ulong)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (ulong)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.19.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.19.cs index 8c9d91e68d..897799e34c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.19.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.19.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ulong)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (ulong)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (ulong)2, 19); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ulong)2, 19); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ulong)2, 19); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt6419(); var result = Avx.Insert(test._fld, (ulong)2, 19); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (ulong)2, 19); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (ulong)2, 19); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.3.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.3.cs index 264018dd4a..01ebedf07f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.3.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Insert.UInt64.3.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ulong)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Insert( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Insert( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Insert), new Type[] { typeof(Vector256), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Insert( _clsVar, (ulong)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Insert(firstOp, (ulong)2, 3); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ulong)2, 3); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx.Insert(firstOp, (ulong)2, 3); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt643(); var result = Avx.Insert(test._fld, (ulong)2, 3); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Insert(_fld, (ulong)2, 3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Insert(test._fld, (ulong)2, 3); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs index 902ef30077..67dea53d8f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Byte.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Byte*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), (Byte*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), (Byte*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Byte*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Byte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Byte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (Byte*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Byte*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = (Byte*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = (Byte*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Byte1(); var result = Avx.InsertVector128(test._fld1, (Byte*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (Byte*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (Byte*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs index df659e4e28..ec052c6df6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Double.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Double*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), (Double*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), (Double*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Double*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Double*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Double*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (Double*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Double*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = (Double*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = (Double*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Double1(); var result = Avx.InsertVector128(test._fld1, (Double*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (Double*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (Double*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs index 26c05f9de6..88848b439c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int16.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Int16*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), (Int16*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), (Int16*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int16*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (Int16*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Int16*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = (Int16*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = (Int16*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Int161(); var result = Avx.InsertVector128(test._fld1, (Int16*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (Int16*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (Int16*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs index 51bd7d4be5..c6759647e8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int32.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Int32*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), (Int32*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), (Int32*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int32*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (Int32*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Int32*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = (Int32*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = (Int32*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Int321(); var result = Avx.InsertVector128(test._fld1, (Int32*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (Int32*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (Int32*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs index 5aec3eed8a..666279512c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Int64.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Int64*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), (Int64*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), (Int64*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int64*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Int64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (Int64*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Int64*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = (Int64*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = (Int64*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Int641(); var result = Avx.InsertVector128(test._fld1, (Int64*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (Int64*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (Int64*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs index b7d1eda5ea..a549fe995e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.SByte.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (SByte*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), (SByte*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), (SByte*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(SByte*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(SByte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(SByte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (SByte*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (SByte*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = (SByte*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = (SByte*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128SByte1(); var result = Avx.InsertVector128(test._fld1, (SByte*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (SByte*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (SByte*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs index 2d5ed89e42..2b3ddf100d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.Single.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Single*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), (Single*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), (Single*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Single*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Single*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(Single*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (Single*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Single*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = (Single*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = (Single*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Single1(); var result = Avx.InsertVector128(test._fld1, (Single*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (Single*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (Single*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs index a41aac85b9..00572a6fb8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt16.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (UInt16*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), (UInt16*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), (UInt16*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt16*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (UInt16*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (UInt16*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = (UInt16*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = (UInt16*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128UInt161(); var result = Avx.InsertVector128(test._fld1, (UInt16*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (UInt16*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (UInt16*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs index 6c26623506..b9774e46a6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt32.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (UInt32*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), (UInt32*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), (UInt32*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt32*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (UInt32*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (UInt32*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = (UInt32*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = (UInt32*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128UInt321(); var result = Avx.InsertVector128(test._fld1, (UInt32*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (UInt32*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (UInt32*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs index 08a5ad0fc3..69c32ca0c0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/InsertVector128.UInt64.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (UInt64*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.InsertVector128( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), (UInt64*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.InsertVector128( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), (UInt64*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt64*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.InsertVector128( _clsVar1, (UInt64*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (UInt64*)_dataTable.inArray2Ptr; var result = Avx.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = (UInt64*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = (UInt64*)(_dataTable.inArray2Ptr); var result = Avx.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128UInt641(); var result = Avx.InsertVector128(test._fld1, (UInt64*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.InsertVector128(_fld1, (UInt64*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.InsertVector128(test._fld1, (UInt64*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs index 064e42b351..ce8141a60f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Max( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Max( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxDouble(); var result = Avx.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs index 5297d63151..f9c33f3b72 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Max.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Max( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Max( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxSingle(); var result = Avx.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs index d478c1eb9a..dd0213de90 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Min( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Min( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinDouble(); var result = Avx.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs index 010dbb42b2..cac123fe68 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Min.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Min( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Min( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinSingle(); var result = Avx.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs index f8be371238..d79b8172e7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Multiply( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Multiply( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Multiply( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Multiply), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Multiply), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Multiply), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Multiply( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Multiply(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Multiply(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Multiply(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplyDouble(); var result = Avx.Multiply(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Multiply(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Multiply(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs index c2f3e5d708..7ce024fe59 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Multiply.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Multiply( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Multiply( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Multiply( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Multiply), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Multiply), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Multiply), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Multiply( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Multiply(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Multiply(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Multiply(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplySingle(); var result = Avx.Multiply(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Multiply(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Multiply(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs index 3d5009e32b..82d948412e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Or( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Or( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrDouble(); var result = Avx.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs index 4c76fe6a63..50da1a6b03 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Or.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Or( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Or( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrSingle(); var result = Avx.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs index d1b6da6d7d..f295c95c62 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Permute( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Permute( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Permute( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Permute( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Permute(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__PermuteDouble1(); var result = Avx.Permute(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Permute(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Permute(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs index 64e724273f..c929189475 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Double.2.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Permute( Unsafe.Read>(_dataTable.inArrayPtr), 2 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Permute( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)), 2 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Permute( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)), 2 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Permute( _clsVar, 2 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Permute(firstOp, 2); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 2); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 2); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__PermuteDouble2(); var result = Avx.Permute(test._fld, 2); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Permute(_fld, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Permute(test._fld, 2); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs index 940853d7f5..2d8c6c7415 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Permute( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Permute( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Permute( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Permute( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Permute(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__PermuteSingle1(); var result = Avx.Permute(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Permute(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Permute(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs index ab34e8d986..58ad78793f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Permute.Single.2.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Permute( Unsafe.Read>(_dataTable.inArrayPtr), 2 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Permute( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)), 2 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Permute( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)), 2 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Permute), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Permute( _clsVar, 2 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.Permute(firstOp, 2); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 2); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx.Permute(firstOp, 2); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__PermuteSingle2(); var result = Avx.Permute(test._fld, 2); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Permute(_fld, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Permute(test._fld, 2); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Double.cs index 641a940f43..b7d72368d7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.PermuteVar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.PermuteVar( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.PermuteVar( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.PermuteVar), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.PermuteVar), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.PermuteVar), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.PermuteVar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.PermuteVar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.PermuteVar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.PermuteVar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__PermuteVarDouble(); var result = Avx.PermuteVar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.PermuteVar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.PermuteVar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Single.cs index 42bbe3b0e9..91f190f7ff 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/PermuteVar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.PermuteVar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.PermuteVar( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.PermuteVar( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.PermuteVar), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.PermuteVar), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.PermuteVar), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.PermuteVar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.PermuteVar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.PermuteVar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.PermuteVar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__PermuteVarSingle(); var result = Avx.PermuteVar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.PermuteVar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.PermuteVar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs index b80af56e96..c99b3398e9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundCurrentDirection( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundCurrentDirection( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundCurrentDirection( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundCurrentDirection), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundCurrentDirection), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundCurrentDirection), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundCurrentDirection( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundCurrentDirection(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundCurrentDirection(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundCurrentDirection(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundCurrentDirectionDouble(); var result = Avx.RoundCurrentDirection(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundCurrentDirection(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundCurrentDirection(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs index c1d2fc9949..df5232ff63 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundCurrentDirection.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundCurrentDirection( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundCurrentDirection( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundCurrentDirection( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundCurrentDirection), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundCurrentDirection), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundCurrentDirection), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundCurrentDirection( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundCurrentDirection(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundCurrentDirection(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundCurrentDirection(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundCurrentDirectionSingle(); var result = Avx.RoundCurrentDirection(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundCurrentDirection(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundCurrentDirection(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs index 92a0cdd008..63bd5e6262 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToNearestInteger( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToNearestInteger( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToNearestInteger( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNearestInteger), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNearestInteger), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNearestInteger), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToNearestInteger( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToNearestInteger(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNearestInteger(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNearestInteger(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNearestIntegerDouble(); var result = Avx.RoundToNearestInteger(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToNearestInteger(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToNearestInteger(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs index 7ac79c6ef2..1f7b2f4956 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNearestInteger.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToNearestInteger( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToNearestInteger( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToNearestInteger( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNearestInteger), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNearestInteger), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNearestInteger), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToNearestInteger( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToNearestInteger(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNearestInteger(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNearestInteger(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNearestIntegerSingle(); var result = Avx.RoundToNearestInteger(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToNearestInteger(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToNearestInteger(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs index 868a618ca7..75c8437b91 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToNegativeInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToNegativeInfinity( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToNegativeInfinity( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNegativeInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNegativeInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNegativeInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToNegativeInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToNegativeInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNegativeInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNegativeInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNegativeInfinityDouble(); var result = Avx.RoundToNegativeInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToNegativeInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToNegativeInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs index b9db66a146..5fcb3e99e3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToNegativeInfinity.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToNegativeInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToNegativeInfinity( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToNegativeInfinity( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNegativeInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNegativeInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToNegativeInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToNegativeInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToNegativeInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNegativeInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToNegativeInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNegativeInfinitySingle(); var result = Avx.RoundToNegativeInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToNegativeInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToNegativeInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs index 869a551d2b..ec5c36022f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToPositiveInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToPositiveInfinity( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToPositiveInfinity( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToPositiveInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToPositiveInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToPositiveInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToPositiveInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToPositiveInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToPositiveInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToPositiveInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToPositiveInfinityDouble(); var result = Avx.RoundToPositiveInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToPositiveInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToPositiveInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs index b087a33004..a4186a0714 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToPositiveInfinity.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToPositiveInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToPositiveInfinity( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToPositiveInfinity( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToPositiveInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToPositiveInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToPositiveInfinity), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToPositiveInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToPositiveInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToPositiveInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToPositiveInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToPositiveInfinitySingle(); var result = Avx.RoundToPositiveInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToPositiveInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToPositiveInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs index 40dc9b1c82..e9d62b7a56 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToZero( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToZero( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToZero( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToZero), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToZero), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToZero), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToZero( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToZero(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToZero(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx.RoundToZero(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToZeroDouble(); var result = Avx.RoundToZero(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToZero(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToZero(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs index 742c5489ba..ad8b5f2477 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/RoundToZero.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.RoundToZero( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.RoundToZero( Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.RoundToZero( Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToZero), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToZero), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.RoundToZero), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.RoundToZero( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx.RoundToZero(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToZero(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArrayPtr)); var result = Avx.RoundToZero(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToZeroSingle(); var result = Avx.RoundToZero(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.RoundToZero(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.RoundToZero(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs index 0549b8a523..08094a7dd8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Double.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Shuffle( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Shuffle( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Shuffle( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Shuffle), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Shuffle), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Shuffle), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Shuffle( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Shuffle(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Shuffle(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Shuffle(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__ShuffleDouble1(); var result = Avx.Shuffle(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Shuffle(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Shuffle(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs index 9797d85fb6..a03f08b078 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Shuffle.Single.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Shuffle( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Shuffle( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Shuffle( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Shuffle), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Shuffle), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Shuffle), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Shuffle( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Shuffle(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Shuffle(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Shuffle(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__ShuffleSingle1(); var result = Avx.Shuffle(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Shuffle(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Shuffle(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs index aa4e58b908..6d2a4390f5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Subtract( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Subtract( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractDouble(); var result = Avx.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs index 9d1fc8dc2b..f1ba50bce5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Subtract.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Subtract( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Subtract( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSingle(); var result = Avx.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs index 59eceec914..99f3b92de5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCByte(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs index c86f8c4aa6..aff1b29c60 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCInt16(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs index 4280c638ef..9ee6568b0c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCInt32(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs index 754b150d80..1ad46c4371 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCInt64(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs index b1c6bd2603..7579e925a9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCSByte(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs index 5b8778e862..a684832606 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCUInt16(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs index 3db1727f75..578cecb986 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCUInt32(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs index 4a64cab72a..c23bb64bfc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestC.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestC( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestC( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCUInt64(); var result = Avx.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs index a838214270..decabff664 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCByte(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs index b95d72bb11..2651d327c1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCInt16(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs index 09430a1f68..4bc925583e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCInt32(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs index 831de17672..b98e7df6f3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCInt64(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs index 1286c0320b..249f69d93a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCSByte(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs index 54d26fc5dc..1e172ce68a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCUInt16(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs index d7b704c4d7..b89594d0e3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCUInt32(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs index afca395cd3..14c874bf22 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestNotZAndNotC.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestNotZAndNotC( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestNotZAndNotC( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCUInt64(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs index 20c7977f3e..0ba1d262d9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZByte(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs index 031a1c7a3f..3c3ed417ea 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZInt16(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs index 07f88c16b1..97e24d09e6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZInt32(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs index b17f040b31..82e4789959 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZInt64(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs index b67905e687..b7daa05bbe 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZSByte(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs index baf72feb0a..38e9ef21f9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZUInt16(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs index 6a46536423..58b249974c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZUInt32(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs index 2d0d3a91c4..b7d0b7d38d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/TestZ.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.TestZ( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.TestZ( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256), typeof(Vector256) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZUInt64(); var result = Avx.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs index d235c81ffa..6970cee298 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Xor( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Xor( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var result = Avx.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorDouble(); var result = Avx.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs index 6c3acd9255..1789c561f4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx/Xor.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx.Xor( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx.Xor( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx).GetMethod(nameof(Avx.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx).GetMethod(nameof(Avx.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx).GetMethod(nameof(Avx.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var result = Avx.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorSingle(); var result = Avx.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs index 6bda38ae7b..4a52e700c5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddByte(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs index 5a9d82909d..2697e12dd9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddInt16(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs index d733b7f9d2..90779f2d2c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddInt32(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs index ba428f5c32..b1d599e8a0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddInt64(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs index eee99142ed..3c50a11404 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSByte(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs index 170c5c5f10..956cb0da95 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddUInt16(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs index ef9973e25c..f34d74322c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddUInt32(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs index 4ae7207d54..679d863515 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Add.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Add( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Add( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Add), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddUInt64(); var result = Avx2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs index 1b795fef73..ee08253331 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.228.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AlignRight( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AlignRight( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AlignRight( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AlignRight( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AlignRight(left, right, 228); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 228); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 228); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__AlignRightSByte228(); var result = Avx2.AlignRight(test._fld1, test._fld2, 228); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AlignRight(_fld1, _fld2, 228); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AlignRight(test._fld1, test._fld2, 228); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs index 2e3f1c2aad..eacf55a73a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.250.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AlignRight( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AlignRight( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AlignRight( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AlignRight( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AlignRight(left, right, 250); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 250); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 250); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__AlignRightSByte250(); var result = Avx2.AlignRight(test._fld1, test._fld2, 250); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AlignRight(_fld1, _fld2, 250); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AlignRight(test._fld1, test._fld2, 250); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs index 6302ada7a9..3a7ffe2930 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.27.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AlignRight( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AlignRight( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AlignRight( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AlignRight( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AlignRight(left, right, 27); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 27); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 27); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__AlignRightSByte27(); var result = Avx2.AlignRight(test._fld1, test._fld2, 27); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AlignRight(_fld1, _fld2, 27); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AlignRight(test._fld1, test._fld2, 27); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs index 19226764e3..722992cadf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AlignRight.SByte.5.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AlignRight( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AlignRight( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AlignRight( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AlignRight), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AlignRight( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AlignRight(left, right, 5); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 5); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AlignRight(left, right, 5); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__AlignRightSByte5(); var result = Avx2.AlignRight(test._fld1, test._fld2, 5); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AlignRight(_fld1, _fld2, 5); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AlignRight(test._fld1, test._fld2, 5); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs index b72961771c..b0f6244412 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndByte(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs index 6ade3a8b7c..260c3feae3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndInt16(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs index 0f7c29988b..8f4c33ba70 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndInt32(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs index e86c18f3a3..6547a31096 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndInt64(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs index b7f2adac46..1e161c1108 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndSByte(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs index f1b86cdc1c..551105b4b5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndUInt16(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs index 28e25795b4..96e3ff73d9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndUInt32(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs index a72bb79ddb..ad1b44af5c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/And.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.And( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.And( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.And), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndUInt64(); var result = Avx2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs index 21d9985ca3..97d155d704 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotByte(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs index 931fda5819..316cf11c3b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotInt16(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs index c5e22c8a92..2fe4dbabba 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotInt32(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs index f025df0448..8456f6244a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotInt64(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs index 4be8ad1822..2eef809fb3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotSByte(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs index 043de10689..26691ea984 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotUInt16(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs index 2474aaac54..bc5fff1195 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotUInt32(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs index 878ea174bb..0ba3f09543 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/AndNot.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.AndNot( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.AndNot( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.AndNot), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotUInt64(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs index 09097ec4a2..3161da713f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Average( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Average( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Average( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Average), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Average), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Average), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Average( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Average(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Average(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Average(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AverageByte(); var result = Avx2.Average(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Average(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Average(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs index 8b550374cb..211667158f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Average.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Average( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Average( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Average( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Average), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Average), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Average), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Average( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Average(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Average(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Average(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AverageUInt16(); var result = Avx2.Average(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Average(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Average(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs index f7d4daf11d..089c366218 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt161(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs index c06f52408c..71be7b6f90 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt162(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs index 49006ef8b2..740ab8b964 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.4.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 4); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt164(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs index 60900f2302..281a69076b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int16.85.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 85); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt1685(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 85); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs index 9af8b1c7c7..318e85ceec 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt321(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs index 3569922475..42c4c72e93 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt322(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs index 0776eacf38..5cc2abe1bf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.4.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 4); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt324(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs index f6e1b423df..5e24848c84 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.Int32.85.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 85); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt3285(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 85); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs index 979d42b241..66029bb736 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt161(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs index f8d0ac30f2..368e4e1e6f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt162(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs index 7b9a2217fd..4f216849f4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.4.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 4); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt164(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs index 4fda2b8f31..a9622cb665 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt16.85.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 85); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt1685(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 85); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs index 2526b8fc25..9748dbbd42 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt321(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs index b74042ce46..41f3997fea 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt322(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs index 0c125ae61c..6c5fdc0c89 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.4.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 4); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt324(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs index ef3a90a1d4..5058fb8001 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Blend.UInt32.85.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 85); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt3285(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 85); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs index f1273b9074..2d997c3dde 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.Byte.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BlendVariable( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BlendVariable( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Byte*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableByte(); var result = Avx2.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs index a931083f44..cbe879db01 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BlendVariable.SByte.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BlendVariable( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BlendVariable( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BlendVariable), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((SByte*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableSByte(); var result = Avx2.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs index 3569e63612..f50136f449 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Byte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128Byte(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs index 20e00b7a4a..cfc18c4afb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128Double(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs index 5f8abb3cfd..a41a7cc5ec 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128Int16(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs index fd95a9f0db..11d98348ca 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128Int32(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs index d80907ab51..a512c346f1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Int64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128Int64(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs index 431a752398..dd02085365 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.SByte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128SByte(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs index d3d797544f..039cf8b6b4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128Single(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs index 2dd930e9b4..784dfa1462 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128UInt16(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs index 30fc94a467..7537422171 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128UInt32(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs index 96901788bb..bfca1e94f5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector128.UInt64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector128( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector128( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector128)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector128( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector128(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector128UInt64(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector128(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs index 326d7d5243..5a314611b0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Byte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Byte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256Byte(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs index 3a55da2210..abb44460c0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Double) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256Double(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs index fba5de8658..3efff459e3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256Int16(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs index 3930db0592..73eb9e02ea 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256Int32(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs index 5a41e09a2e..b852443468 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Int64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Int64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256Int64(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs index d8dcd7afcb..2f5a7c57a0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.SByte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(SByte) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256SByte(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs index c17c3bd232..f038820d9c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(Single) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256Single(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs index ab54934ec6..8d25d3da47 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256UInt16(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs index 71b0037cfb..64c768fdec 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256UInt32(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs index a3c6e99010..6ec49c0966 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/BroadcastScalarToVector256.UInt64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.BroadcastScalarToVector256( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.BroadcastScalarToVector256( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -192,6 +200,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -204,6 +214,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.BroadcastScalarToVector256)) .MakeGenericMethod( new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { @@ -216,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.BroadcastScalarToVector256( _clsVar ); @@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -235,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -244,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.BroadcastScalarToVector256(firstOp); @@ -253,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new GenericUnaryOpTest__BroadcastScalarToVector256UInt64(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.BroadcastScalarToVector256(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -270,6 +294,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.BroadcastScalarToVector256(test._fld); @@ -279,12 +305,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs index e90e848627..1654f17ece 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualByte(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs index f7ab8a40da..dc9b309a3d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualInt16(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs index 0c47c48047..a980f001d3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualInt32(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs index abff21b774..855836826f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualInt64(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs index c7650b5c2f..c69ab10914 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualSByte(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs index 518843b553..6e15b8076c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualUInt16(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs index f4c041ca30..0f188ebd1f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualUInt32(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs index c5c0874880..23d74edc7e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareEqual.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareEqual( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareEqual( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareEqual), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualUInt64(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs index 9ba9ffaa7f..f56b68069e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareGreaterThan( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareGreaterThan( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanInt16(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs index afc6908617..880366975c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareGreaterThan( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareGreaterThan( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanInt32(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs index 9c88e82b39..ee8cc36f67 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareGreaterThan( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareGreaterThan( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanInt64(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs index 2399589551..f1e7eecfac 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/CompareGreaterThan.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.CompareGreaterThan( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.CompareGreaterThan( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.CompareGreaterThan), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanSByte(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToDouble.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToDouble.Double.cs index 3603a384de..8f000e3775 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToDouble.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToDouble.Double.cs @@ -147,6 +147,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ConvertToDouble( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -156,6 +158,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ConvertToDouble( Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -165,6 +169,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ConvertToDouble( Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) ); @@ -174,6 +180,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToDouble), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -184,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToDouble), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)) @@ -194,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToDouble), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)) @@ -204,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ConvertToDouble( _clsVar ); @@ -213,6 +227,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ConvertToDouble(firstOp); @@ -221,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx2.ConvertToDouble(firstOp); @@ -229,6 +247,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArrayPtr)); var result = Avx2.ConvertToDouble(firstOp); @@ -237,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimdScalarUnaryOpTest__ConvertToDoubleDouble(); var result = Avx2.ConvertToDouble(test._fld); @@ -245,6 +267,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ConvertToDouble(_fld); ValidateResult(_fld, result); @@ -252,6 +276,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ConvertToDouble(test._fld); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs index 5370d7491a..0848ed965d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToInt32.Int32.cs @@ -147,6 +147,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ConvertToInt32( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -156,6 +158,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ConvertToInt32( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)) ); @@ -165,6 +169,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ConvertToInt32( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)) ); @@ -174,6 +180,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToInt32), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -184,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToInt32), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)) @@ -194,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToInt32), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)) @@ -204,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ConvertToInt32( _clsVar ); @@ -213,6 +227,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ConvertToInt32(firstOp); @@ -221,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ConvertToInt32(firstOp); @@ -229,6 +247,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ConvertToInt32(firstOp); @@ -237,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimdScalarUnaryOpTest__ConvertToInt32Int32(); var result = Avx2.ConvertToInt32(test._fld); @@ -245,6 +267,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ConvertToInt32(_fld); ValidateResult(_fld, result); @@ -252,6 +276,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ConvertToInt32(test._fld); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs index ed212fce08..0d12229de5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ConvertToUInt32.UInt32.cs @@ -147,6 +147,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ConvertToUInt32( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -156,6 +158,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ConvertToUInt32( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)) ); @@ -165,6 +169,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ConvertToUInt32( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)) ); @@ -174,6 +180,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToUInt32), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -184,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToUInt32), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)) @@ -194,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ConvertToUInt32), new Type[] { typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)) @@ -204,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ConvertToUInt32( _clsVar ); @@ -213,6 +227,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ConvertToUInt32(firstOp); @@ -221,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ConvertToUInt32(firstOp); @@ -229,6 +247,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ConvertToUInt32(firstOp); @@ -237,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimdScalarUnaryOpTest__ConvertToUInt32UInt32(); var result = Avx2.ConvertToUInt32(test._fld); @@ -245,6 +267,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ConvertToUInt32(_fld); ValidateResult(_fld, result); @@ -252,6 +276,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ConvertToUInt32(test._fld); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs index b297302321..f48e72be4a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (Byte*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (Byte*)_dataTable.outArrayPtr, Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (Byte*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Byte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Byte*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Byte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Byte*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Byte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Byte*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (Byte*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((Byte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Byte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Byte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Byte1(); Avx2.ExtractVector128((Byte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((Byte*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((Byte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs index b3bfb57d1d..3149e76475 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128Byte1(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs index bbd82399d6..855974f4bc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (Int16*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (Int16*)_dataTable.outArrayPtr, Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (Int16*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int16*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int16*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int16*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (Int16*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((Int16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Int16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Int16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Int161(); Avx2.ExtractVector128((Int16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((Int16*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((Int16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs index a0b21e6248..67e0457ba8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128Int161(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs index 4a8e245b6f..6a58279bc0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (Int32*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (Int32*)_dataTable.outArrayPtr, Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (Int32*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int32*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int32*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int32*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (Int32*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((Int32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Int32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Int32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Int321(); Avx2.ExtractVector128((Int32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((Int32*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((Int32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs index 0a3d2d4c2d..609a149e57 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128Int321(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs index 81b3508338..45c4dfa187 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (Int64*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (Int64*)_dataTable.outArrayPtr, Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (Int64*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int64*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int64*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Int64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(Int64*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (Int64*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((Int64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Int64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((Int64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128Int641(); Avx2.ExtractVector128((Int64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((Int64*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((Int64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs index 68a828c18d..a87099428a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128Int641(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs index 8a5ef18cb7..d2ae2487d7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (SByte*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (SByte*)_dataTable.outArrayPtr, Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (SByte*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(SByte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(SByte*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(SByte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(SByte*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(SByte*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(SByte*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (SByte*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((SByte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((SByte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((SByte*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128SByte1(); Avx2.ExtractVector128((SByte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((SByte*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((SByte*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs index 23e00389b2..85dc468da6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.SByte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128SByte1(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs index 8686a39261..3fdf5a534e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt16*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt16*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt16*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt16*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (UInt16*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((UInt16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((UInt16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((UInt16*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128UInt161(); Avx2.ExtractVector128((UInt16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((UInt16*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((UInt16*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs index 1785cb4d70..a05b91035c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128UInt161(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs index e333ddcd6a..dd580b2dfd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt32*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt32*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt32*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt32*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (UInt32*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((UInt32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((UInt32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((UInt32*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128UInt321(); Avx2.ExtractVector128((UInt32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((UInt32*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((UInt32*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs index 2381a4af5d..585e2a4d45 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128UInt321(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs index 28ec5e3a05..c2c822decc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.Store.cs @@ -149,6 +149,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + Avx2.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, Unsafe.Read>(_dataTable.inArrayPtr), @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + Avx2.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -171,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + Avx2.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -182,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt64*)), @@ -194,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt64*)), @@ -206,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(UInt64*), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Pointer.Box(_dataTable.outArrayPtr, typeof(UInt64*)), @@ -218,6 +230,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + Avx2.ExtractVector128( (UInt64*)_dataTable.outArrayPtr, _clsVar, @@ -229,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); Avx2.ExtractVector128((UInt64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -236,6 +252,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((UInt64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -243,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); Avx2.ExtractVector128((UInt64*)_dataTable.outArrayPtr, firstOp, 1); ValidateResult(firstOp, _dataTable.outArrayPtr); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractStoreTest__ExtractVector128UInt641(); Avx2.ExtractVector128((UInt64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -257,12 +279,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + Avx2.ExtractVector128((UInt64*)_dataTable.outArrayPtr, _fld, 1); ValidateResult(_fld, _dataTable.outArrayPtr); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); Avx2.ExtractVector128((UInt64*)_dataTable.outArrayPtr, test._fld, 1); ValidateResult(test._fld, _dataTable.outArrayPtr); @@ -270,12 +296,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs index 012596a0a1..046abc0642 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ExtractVector128.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ExtractVector128( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ExtractVector128( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ExtractVector128( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ExtractVector128), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ExtractVector128( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ExtractVector128(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ExtractVector128(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractVector128Test__ExtractVector128UInt641(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ExtractVector128(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ExtractVector128(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs index 3937a41911..4b131b2228 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Byte*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), (Byte*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), (Byte*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Byte*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Byte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Byte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (Byte*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Byte*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = (Byte*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = (Byte*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Byte1(); var result = Avx2.InsertVector128(test._fld1, (Byte*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (Byte*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (Byte*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs index d899d9a523..a305f31cc5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Byte.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), LoadVector128((Byte*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128Byte1(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs index 0e230fa924..1d17770798 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Int16*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), (Int16*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), (Int16*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int16*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (Int16*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Int16*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = (Int16*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = (Int16*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Int161(); var result = Avx2.InsertVector128(test._fld1, (Int16*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (Int16*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (Int16*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs index 7f7fd5b1b6..b9b205f857 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int16.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), LoadVector128((Int16*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128Int161(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs index 24de44b06c..0b060c27b4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Int32*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), (Int32*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), (Int32*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int32*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (Int32*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Int32*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = (Int32*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = (Int32*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Int321(); var result = Avx2.InsertVector128(test._fld1, (Int32*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (Int32*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (Int32*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs index ebfe0a1f20..bc31f53ba3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int32.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), LoadVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128Int321(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs index 18371b2a87..08cd64a5c2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (Int64*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), (Int64*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), (Int64*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int64*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Int64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (Int64*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (Int64*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = (Int64*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = (Int64*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128Int641(); var result = Avx2.InsertVector128(test._fld1, (Int64*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (Int64*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (Int64*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs index 6cb0e084b4..7dc2e765b7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.Int64.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), LoadVector128((Int64*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128Int641(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs index 2674a9df18..0cd5d246e1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (SByte*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), (SByte*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), (SByte*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(SByte*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(SByte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(SByte*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (SByte*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (SByte*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = (SByte*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = (SByte*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128SByte1(); var result = Avx2.InsertVector128(test._fld1, (SByte*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (SByte*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (SByte*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs index 0c35f40135..da733ac2a3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.SByte.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), LoadVector128((SByte*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128SByte1(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs index 701c6fca74..4384854243 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (UInt16*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), (UInt16*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), (UInt16*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt16*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt16*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (UInt16*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (UInt16*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = (UInt16*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = (UInt16*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128UInt161(); var result = Avx2.InsertVector128(test._fld1, (UInt16*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (UInt16*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (UInt16*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs index cf7bb16fca..770435cee5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt16.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), LoadVector128((UInt16*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = LoadVector128((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128UInt161(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs index 750cbbe3c8..46ab7a38a4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (UInt32*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), (UInt32*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), (UInt32*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt32*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt32*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (UInt32*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (UInt32*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = (UInt32*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = (UInt32*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128UInt321(); var result = Avx2.InsertVector128(test._fld1, (UInt32*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (UInt32*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (UInt32*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs index 45b1f4cd13..2a1b551e72 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt32.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), LoadVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128UInt321(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs index 187411def3..4009cd508d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.Load.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), (UInt64*)_dataTable.inArray2Ptr, @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), (UInt64*)(_dataTable.inArray2Ptr), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), (UInt64*)(_dataTable.inArray2Ptr), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt64*), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(UInt64*), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, (UInt64*)_dataTable.inArray2Ptr, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = (UInt64*)_dataTable.inArray2Ptr; var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = (UInt64*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = (UInt64*)(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertLoadTest__InsertVector128UInt641(); var result = Avx2.InsertVector128(test._fld1, (UInt64*)(_dataTable.inArray2Ptr), 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, (UInt64*)(_dataTable.inArray2Ptr), 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, (UInt64*)(_dataTable.inArray2Ptr), 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs index 3624efdf76..30fe823d36 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/InsertVector128.UInt64.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.InsertVector128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.InsertVector128( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), LoadVector128((UInt64*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.InsertVector128( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.InsertVector128), new Type[] { typeof(Vector256), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.InsertVector128( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.InsertVector128(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.InsertVector128(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertVector128UInt641(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.InsertVector128(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.InsertVector128(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs index d4cb9f62fe..a232b979eb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Max( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Max( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxByte(); var result = Avx2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs index b5ef504b14..8d35d450f6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Max( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Max( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxInt16(); var result = Avx2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs index f6a6525990..b32d0531f9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Max( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Max( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxInt32(); var result = Avx2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs index 3bff66d58d..517d6b9abe 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Max( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Max( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxSByte(); var result = Avx2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs index 1fc3722890..21016eb62e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Max( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Max( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxUInt16(); var result = Avx2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs index 8f23998ebb..4e572876ec 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Max.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Max( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Max( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Max), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxUInt32(); var result = Avx2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs index 1e457f4583..8725c8eb6f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Min( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Min( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinByte(); var result = Avx2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs index b960f75644..b9d65de083 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Min( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Min( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinInt16(); var result = Avx2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs index 36f40b7740..0b63051310 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Min( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Min( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinInt32(); var result = Avx2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs index b5da9d8cf7..16db4300ae 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Min( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Min( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinSByte(); var result = Avx2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs index 68ab018abf..5a61d0ec2b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Min( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Min( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinUInt16(); var result = Avx2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs index d1016d2cfc..bc761a1ae9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Min.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Min( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Min( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Min), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinUInt32(); var result = Avx2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs index 6a3a348c69..9748943f1b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrByte(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs index 3a8bf57eb0..1a2b989e2e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrInt16(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs index 9f07d53bfc..93c12908e7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrInt32(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs index 777716647b..b6e3fa8139 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrInt64(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs index 65ce6433dd..2ce37872bf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrSByte(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs index 82e7171cd3..3bcf133225 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrUInt16(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs index 3ac45db15d..b04da6f2bd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrUInt32(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs index 7fffb77dfe..3abe2672b1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Or.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Or( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Or( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Or), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrUInt64(); var result = Avx2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs index b670def3fb..95bd612bd8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int32.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Permute2x128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Permute2x128( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Permute2x128( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Permute2x128( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Permute2x128(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__Permute2x128Int322(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Permute2x128(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs index 2fb8dbb3af..f235f8ceef 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.Int64.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Permute2x128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Permute2x128( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Permute2x128( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Permute2x128( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Permute2x128(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__Permute2x128Int642(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Permute2x128(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs index 0476216d54..f5c65d1337 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt32.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Permute2x128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Permute2x128( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Permute2x128( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Permute2x128( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Permute2x128(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__Permute2x128UInt322(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Permute2x128(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs index 19579fe42c..14d7bf2ad4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Permute2x128.UInt64.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Permute2x128( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Permute2x128( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Permute2x128( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Permute2x128), new Type[] { typeof(Vector256), typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Permute2x128( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Permute2x128(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Permute2x128(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__Permute2x128UInt642(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Permute2x128(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Permute2x128(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs index a6329497aa..61cc47eb51 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt161(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs index cd577228c0..f2b7c6e6bb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt1616(); var result = Avx2.ShiftLeftLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs index 39bbeb3cca..20f0ae8e9f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt321(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs index 6cf4c10fe8..99759779ad 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt3232(); var result = Avx2.ShiftLeftLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs index b89d3e224c..c7409a01a5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt641(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs index 496b5ec3cb..8f628f91c8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.Int64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt6464(); var result = Avx2.ShiftLeftLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs index dc1c6ab3de..d84b46e33f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt161(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs index 4b60e5f8ce..0c4dbcd1d7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt1616(); var result = Avx2.ShiftLeftLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs index 92ebe0e33a..ac8519e753 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt321(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs index 44ecac222c..bdc58b541d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt3232(); var result = Avx2.ShiftLeftLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs index 7d8aed5b18..9590c3edb1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt641(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs index c27baf3eda..3ee6cb9ee6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical.UInt64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt6464(); var result = Avx2.ShiftLeftLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs index 9a4dc7e358..c4802f32cb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneByte1(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs index 9b641d3140..903b2a3199 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneInt161(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs index c98772e345..e92560ff6c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneInt321(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs index 7b21ae6c68..231406454d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneInt641(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs index 593cf147e5..4dc13fca68 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.SByte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneSByte1(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs index 8667c7b2c8..864a3a2748 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneUInt161(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs index b3f6d9ae92..becf8bc284 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneUInt321(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs index 03c8a250c9..72a57bbaec 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftLeftLogical128BitLane.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftLeftLogical128BitLane( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneUInt641(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs index 8b9651b78b..206a6326be 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightArithmetic( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightArithmetic(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt161(); var result = Avx2.ShiftRightArithmetic(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightArithmetic(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightArithmetic(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs index 9eec392b74..ece284e0e7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightArithmetic( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightArithmetic(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt1616(); var result = Avx2.ShiftRightArithmetic(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightArithmetic(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightArithmetic(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs index 04b0e19fcc..e5abdf4479 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightArithmetic( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightArithmetic(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt321(); var result = Avx2.ShiftRightArithmetic(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightArithmetic(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightArithmetic(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs index ca39cba1f1..9907120245 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightArithmetic.Int32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightArithmetic( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightArithmetic), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightArithmetic( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightArithmetic(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightArithmetic(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt3232(); var result = Avx2.ShiftRightArithmetic(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightArithmetic(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightArithmetic(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs index 2956b3f64b..6c28a9e38a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt161(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs index 8380732537..02e7709fcf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt1616(); var result = Avx2.ShiftRightLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs index 11c671c886..816be27fdc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt321(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs index 193b73f0d2..bfbc26c5c3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt3232(); var result = Avx2.ShiftRightLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs index 236dc0ef73..1ecff8eac0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt641(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs index 46e195ecc2..c13fd14e68 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.Int64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt6464(); var result = Avx2.ShiftRightLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs index bec0203a25..63e75b62f2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt161(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs index 44e59f4c2d..95679e0f4a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt1616(); var result = Avx2.ShiftRightLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs index 061ac8f535..4c471013ee 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt321(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs index d3bf4649b4..c6b08a6a55 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt3232(); var result = Avx2.ShiftRightLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs index 31bc34bee1..8ab8ad6312 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt641(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs index 66d1cd0ef9..d495579041 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical.UInt64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt6464(); var result = Avx2.ShiftRightLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs index e5ae5556b8..e3b4ece725 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneByte1(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs index 8c31e22958..e00a1e2e26 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneInt161(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs index 197e2534f6..043aa70a96 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneInt321(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs index a197b9df6d..b82237628d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneInt641(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs index 35b5f5e433..51e9e2d38e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.SByte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneSByte1(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs index aa6ce9da54..5bdaaed255 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneUInt161(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs index 968cfb2fb8..dd139de62f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneUInt321(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs index ed0b70b01d..7db842bdf5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/ShiftRightLogical128BitLane.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.ShiftRightLogical128BitLane( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector256), typeof(byte) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArrayPtr)); var result = Avx2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneUInt641(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs index 9464629bc1..3e43dd675f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractByte(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs index 37628d004f..dc7722e791 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractInt16(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs index 06721cffbf..617108529c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractInt32(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs index 8fef9c4259..3b5b14ab17 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractInt64(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs index 60b6216fee..0813bcd682 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSByte(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs index 130d725e9b..0f9d5ef5d7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractUInt16(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs index 21ec9123a4..aaa71a6333 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractUInt32(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs index 1613aca564..42a42bb573 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Subtract.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Subtract( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Subtract( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Subtract), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractUInt64(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs index a958fa5c98..caf75ce3c1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Byte*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorByte(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs index a75a61b573..63bf5c1f35 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int16*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorInt16(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs index b12b34d1e2..6d23e23e98 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorInt32(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs index 8ad689f99d..12bb07c829 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((Int64*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorInt64(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs index 74d6a1ae33..c33e8cd428 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((SByte*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorSByte(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs index d1d7de9af5..15d2258558 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt16*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorUInt16(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs index 972e78c4c5..a634971d3b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorUInt32(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs index 65c74b6492..71ea147f1b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2/Xor.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Xor( Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Xor( Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Xor), new Type[] { typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Avx.LoadVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray1Ptr)); var right = Avx.LoadAlignedVector256((UInt64*)(_dataTable.inArray2Ptr)); var result = Avx2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorUInt64(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs index af57e0051b..a854f9eb13 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt321(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs index 18d46ec3cf..a8f974e279 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt322(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs index f816decefe..c80fa33706 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.4.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 4); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt324(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs index a8a338a286..5b0c176364 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.Int32.85.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 85); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendInt3285(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 85); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs index 327c40a45b..17fb0b9693 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.1.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 1); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 1); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt321(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 1); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs index 2fc0d1b064..88bb397443 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.2.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 2); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 2); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt322(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 2); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs index 62a4afaac5..30e0996224 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.4.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 4); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 4); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt324(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 4); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs index d43d56c0e8..6ccc1470a7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Avx2_Vector128/Blend.UInt32.85.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Avx2.Blend( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -174,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Avx2.Blend( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -186,6 +190,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Avx2.Blend( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)), @@ -198,6 +204,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -211,6 +219,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -224,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -237,6 +249,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Avx2.Blend( _clsVar1, _clsVar2, @@ -249,6 +263,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Avx2.Blend(left, right, 85); @@ -259,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -269,6 +287,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Avx2.Blend(left, right, 85); @@ -279,6 +299,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmBinaryOpTest__BlendUInt3285(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -288,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Avx2.Blend(_fld1, _fld2, 85); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -296,6 +320,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Avx2.Blend(test._fld1, test._fld2, 85); @@ -305,12 +331,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs index 67761550a9..4ee3afb045 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt32.cs @@ -118,6 +118,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.AndNot( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)) @@ -128,6 +130,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.AndNot), new Type[] { typeof(UInt32), typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), @@ -139,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.AndNot( _clsVar1, _clsVar2 @@ -149,6 +155,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data1 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)); var data2 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)); var result = Bmi1.AndNot(data1, data2); @@ -158,6 +166,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarBinaryOpTest__AndNotUInt32(); var result = Bmi1.AndNot(test._fld1, test._fld2); @@ -166,12 +176,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.AndNot(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.AndNot(test._fld1, test._fld2); @@ -180,12 +194,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs index 39ad725b08..8855e1e6eb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/AndNot.UInt64.cs @@ -118,6 +118,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.AndNot( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)) @@ -128,6 +130,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.AndNot), new Type[] { typeof(UInt64), typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), @@ -139,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.AndNot( _clsVar1, _clsVar2 @@ -149,6 +155,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data1 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)); var data2 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)); var result = Bmi1.AndNot(data1, data2); @@ -158,6 +166,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarBinaryOpTest__AndNotUInt64(); var result = Bmi1.AndNot(test._fld1, test._fld2); @@ -166,12 +176,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.AndNot(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.AndNot(test._fld1, test._fld2); @@ -180,12 +194,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs index 7a1b55b107..e253031708 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt32.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.ExtractLowestSetBit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.ExtractLowestSetBit), new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.ExtractLowestSetBit( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.ExtractLowestSetBit(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__ExtractLowestSetBitUInt32(); var result = Bmi1.ExtractLowestSetBit(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.ExtractLowestSetBit(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.ExtractLowestSetBit(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs index 8604a35aff..035440aa9a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ExtractLowestSetBit.UInt64.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.ExtractLowestSetBit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.ExtractLowestSetBit), new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.ExtractLowestSetBit( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.ExtractLowestSetBit(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__ExtractLowestSetBitUInt64(); var result = Bmi1.ExtractLowestSetBit(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.ExtractLowestSetBit(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.ExtractLowestSetBit(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs index ba5d28eab1..3b1bb155cc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt32.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.GetMaskUpToLowestSetBit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.GetMaskUpToLowestSetBit), new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.GetMaskUpToLowestSetBit( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.GetMaskUpToLowestSetBit(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__GetMaskUpToLowestSetBitUInt32(); var result = Bmi1.GetMaskUpToLowestSetBit(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.GetMaskUpToLowestSetBit(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.GetMaskUpToLowestSetBit(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs index 8e74430575..b72308407b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/GetMaskUpToLowestSetBit.UInt64.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.GetMaskUpToLowestSetBit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.GetMaskUpToLowestSetBit), new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.GetMaskUpToLowestSetBit( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.GetMaskUpToLowestSetBit(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__GetMaskUpToLowestSetBitUInt64(); var result = Bmi1.GetMaskUpToLowestSetBit(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.GetMaskUpToLowestSetBit(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.GetMaskUpToLowestSetBit(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs index 8b30112f29..293e62211c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt32.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.ResetLowestSetBit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.ResetLowestSetBit), new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.ResetLowestSetBit( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.ResetLowestSetBit(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__ResetLowestSetBitUInt32(); var result = Bmi1.ResetLowestSetBit(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.ResetLowestSetBit(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.ResetLowestSetBit(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs index e98f2ac6fc..11e7a7c89c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/ResetLowestSetBit.UInt64.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.ResetLowestSetBit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.ResetLowestSetBit), new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.ResetLowestSetBit( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.ResetLowestSetBit(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__ResetLowestSetBitUInt64(); var result = Bmi1.ResetLowestSetBit(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.ResetLowestSetBit(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.ResetLowestSetBit(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs index 39be3a4b85..16699cd922 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt32.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.TrailingZeroCount( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.TrailingZeroCount), new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.TrailingZeroCount( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.TrailingZeroCount(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__TrailingZeroCountUInt32(); var result = Bmi1.TrailingZeroCount(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.TrailingZeroCount(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.TrailingZeroCount(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs index a95b143a44..9eb1abf2b6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi1/TrailingZeroCount.UInt64.cs @@ -109,6 +109,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi1.TrailingZeroCount( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -118,6 +120,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi1).GetMethod(nameof(Bmi1.TrailingZeroCount), new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -128,6 +132,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi1.TrailingZeroCount( _clsVar ); @@ -137,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Bmi1.TrailingZeroCount(data); @@ -145,6 +153,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarUnaryOpTest__TrailingZeroCountUInt64(); var result = Bmi1.TrailingZeroCount(test._fld); @@ -153,12 +163,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi1.TrailingZeroCount(_fld); ValidateResult(_fld, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi1.TrailingZeroCount(test._fld); @@ -167,12 +181,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs index 9bdac88607..b3369e209a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt32.cs @@ -118,6 +118,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi2.ParallelBitDeposit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)) @@ -128,6 +130,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi2).GetMethod(nameof(Bmi2.ParallelBitDeposit), new Type[] { typeof(UInt32), typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), @@ -139,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi2.ParallelBitDeposit( _clsVar1, _clsVar2 @@ -149,6 +155,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data1 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)); var data2 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)); var result = Bmi2.ParallelBitDeposit(data1, data2); @@ -158,6 +166,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarBinaryOpTest__ParallelBitDepositUInt32(); var result = Bmi2.ParallelBitDeposit(test._fld1, test._fld2); @@ -166,12 +176,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi2.ParallelBitDeposit(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi2.ParallelBitDeposit(test._fld1, test._fld2); @@ -180,12 +194,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs index 4a97366e6e..144611c03b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitDeposit.UInt64.cs @@ -118,6 +118,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi2.ParallelBitDeposit( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)) @@ -128,6 +130,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi2).GetMethod(nameof(Bmi2.ParallelBitDeposit), new Type[] { typeof(UInt64), typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), @@ -139,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi2.ParallelBitDeposit( _clsVar1, _clsVar2 @@ -149,6 +155,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data1 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)); var data2 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)); var result = Bmi2.ParallelBitDeposit(data1, data2); @@ -158,6 +166,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarBinaryOpTest__ParallelBitDepositUInt64(); var result = Bmi2.ParallelBitDeposit(test._fld1, test._fld2); @@ -166,12 +176,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi2.ParallelBitDeposit(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi2.ParallelBitDeposit(test._fld1, test._fld2); @@ -180,12 +194,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs index f9b47979e1..ea316466f7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt32.cs @@ -118,6 +118,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi2.ParallelBitExtract( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)) @@ -128,6 +130,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi2).GetMethod(nameof(Bmi2.ParallelBitExtract), new Type[] { typeof(UInt32), typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), @@ -139,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi2.ParallelBitExtract( _clsVar1, _clsVar2 @@ -149,6 +155,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data1 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)); var data2 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)); var result = Bmi2.ParallelBitExtract(data1, data2); @@ -158,6 +166,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarBinaryOpTest__ParallelBitExtractUInt32(); var result = Bmi2.ParallelBitExtract(test._fld1, test._fld2); @@ -166,12 +176,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi2.ParallelBitExtract(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi2.ParallelBitExtract(test._fld1, test._fld2); @@ -180,12 +194,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs index 3d69ba2019..faff29100a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Bmi2/ParallelBitExtract.UInt64.cs @@ -118,6 +118,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Bmi2.ParallelBitExtract( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)) @@ -128,6 +130,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Bmi2).GetMethod(nameof(Bmi2.ParallelBitExtract), new Type[] { typeof(UInt64), typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)), @@ -139,6 +143,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Bmi2.ParallelBitExtract( _clsVar1, _clsVar2 @@ -149,6 +155,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data1 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data1)); var data2 = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data2)); var result = Bmi2.ParallelBitExtract(data1, data2); @@ -158,6 +166,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarBinaryOpTest__ParallelBitExtractUInt64(); var result = Bmi2.ParallelBitExtract(test._fld1, test._fld2); @@ -166,12 +176,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Bmi2.ParallelBitExtract(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); } public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Bmi2.ParallelBitExtract(test._fld1, test._fld2); @@ -180,12 +194,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs index b9911ba3a5..742b220e9c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAdd( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAdd( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddDouble(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs index ee0ed200f6..470b2a205a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAdd.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAdd( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAdd( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddSingle(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs index 4c79102b02..2ed78b6708 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddNegated( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddNegated( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddNegatedDouble(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs index 7e0978a5fd..ee5984cad9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegated.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddNegated( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddNegated( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddNegatedSingle(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs index a737f0dede..5e9bc3b2ba 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddNegatedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddNegatedScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddNegatedScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddNegatedScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddNegatedScalarDouble(); var result = Fma.MultiplyAddNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddNegatedScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs index 1082025176..6a3f8fa187 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddNegatedScalar.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddNegatedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddNegatedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddNegatedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddNegatedScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddNegatedScalarSingle(); var result = Fma.MultiplyAddNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddNegatedScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs index f97a8537f5..9b069dd849 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddScalarDouble(); var result = Fma.MultiplyAddScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs index 15eeddfc4b..5b04a7bf74 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddScalar.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddScalarSingle(); var result = Fma.MultiplyAddScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs index 72d9aefd2d..1ebdb8d2a6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddSubtract( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddSubtract( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddSubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplyAddSubtractDouble(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddSubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs index 9ad02bbdef..bafd48bbd6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplyAddSubtract.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddSubtract( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddSubtract( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddSubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplyAddSubtractSingle(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddSubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs index 2b218a9a18..49b8b3febe 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtract( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtract( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractDouble(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs index 4aa9166be6..c955d90c25 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtract.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtract( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtract( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractSingle(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs index 705b0792d5..5c30cd355a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractAdd( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractAdd( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplySubtractAddDouble(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs index ce474b40a7..f0f4919299 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractAdd.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractAdd( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractAdd( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplySubtractAddSingle(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs index 4f8f337db9..a5399c6834 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractNegated( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractNegated( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractNegatedDouble(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs index 530727cb34..55e535a80f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegated.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractNegated( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractNegated( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractNegatedSingle(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs index 71a35f7ba1..d9b7868ce5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractNegatedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractNegatedScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractNegatedScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractNegatedScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractNegatedScalarDouble(); var result = Fma.MultiplySubtractNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractNegatedScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs index 7f6a12d706..3a3cd27dcf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractNegatedScalar.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractNegatedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractNegatedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractNegatedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegatedScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractNegatedScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractNegatedScalarSingle(); var result = Fma.MultiplySubtractNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractNegatedScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractNegatedScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs index f2934437c6..d8f961023e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractScalarDouble(); var result = Fma.MultiplySubtractScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs index 8c7e6638e2..cdc8b8a8be 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector128/MultiplySubtractScalar.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractScalar( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractScalarSingle(); var result = Fma.MultiplySubtractScalar(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractScalar(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractScalar(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs index 5a3d67b1f2..ef5c7388d4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAdd( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAdd( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddDouble(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs index 5d81695fff..985df3df79 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAdd.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAdd( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAdd( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddSingle(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs index 8d51612626..19d4ff5b95 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddNegated( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddNegated( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddNegatedDouble(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs index ad04c8937f..4ffe8bb586 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddNegated.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddNegated( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddNegated( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplyAddNegatedSingle(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs index 3cb27f2496..1d56a8f7e7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddSubtract( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddSubtract( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddSubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplyAddSubtractDouble(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddSubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs index 301a2a3915..902eea9cb9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplyAddSubtract.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplyAddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplyAddSubtract( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplyAddSubtract( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplyAddSubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplyAddSubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplyAddSubtractSingle(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplyAddSubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplyAddSubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs index 6a8f6d3734..1320f504ff 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtract( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtract( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractDouble(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs index ca134ca719..bced88dff0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtract.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtract( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtract( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtract), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtract( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractSingle(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtract(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtract(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs index 9ff40d78a3..1fa290f784 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractAdd( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractAdd( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplySubtractAddDouble(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs index db5aaa99a7..8d5c762d1a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractAdd.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractAdd( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractAdd( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractAdd), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractAdd( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingTernaryOpTest__MultiplySubtractAddSingle(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractAdd(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractAdd(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs index c88c066b92..17b5381ea6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractNegated( Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractNegated( Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractNegatedDouble(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs index cbb211aff3..def77d8a5d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Fma_Vector256/MultiplySubtractNegated.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Fma.MultiplySubtractNegated( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Fma.MultiplySubtractNegated( Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Fma.MultiplySubtractNegated( Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector256), typeof(Vector256), typeof(Vector256) }) .Invoke(null, new object[] { Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Fma.MultiplySubtractNegated( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Avx.LoadVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadVector256((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray1Ptr)); var secondOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Avx.LoadAlignedVector256((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__MultiplySubtractNegatedSingle(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Fma.MultiplySubtractNegated(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Fma.MultiplySubtractNegated(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs index 6bc21466b8..060812f83d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Add.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Add( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Add( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSingle(); var result = Sse.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs index d35b6cf427..a071420c6c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AddScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.AddScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.AddScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.AddScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.AddScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.AddScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.AddScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.AddScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.AddScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.AddScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.AddScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddScalarSingle(); var result = Sse.AddScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.AddScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.AddScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs index a7b0ddfd34..77c00aead9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/And.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.And( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.And( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndSingle(); var result = Sse.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs index 8f721c650d..971b3fb72f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/AndNot.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.AndNot( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.AndNot( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotSingle(); var result = Sse.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs index 3388472a5f..4a76f55be4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqual.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareEqual( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareEqual( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualSingle(); var result = Sse.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs index 672fe3972c..8100dd897c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualOrderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareEqualOrderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareEqualOrderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareEqualOrderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareEqualOrderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareEqualOrderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqualOrderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqualOrderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareEqualOrderedScalarBoolean(); var result = Sse.CompareEqualOrderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareEqualOrderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareEqualOrderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs index db824ea8da..1541aee6f6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareEqualScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareEqualScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareEqualScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareEqualScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareEqualScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqualScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqualScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualScalarSingle(); var result = Sse.CompareEqualScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareEqualScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareEqualScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs index b074e2ea6b..9c4a443540 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareEqualUnorderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareEqualUnorderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareEqualUnorderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareEqualUnorderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareEqualUnorderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareEqualUnorderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqualUnorderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareEqualUnorderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareEqualUnorderedScalarBoolean(); var result = Sse.CompareEqualUnorderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareEqualUnorderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareEqualUnorderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs index f45d04492b..3545190832 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThan.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThan( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThan( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanSingle(); var result = Sse.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs index dbaba373de..16a8a6900a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqual.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThanOrEqual( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThanOrEqual( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualSingle(); var result = Sse.CompareGreaterThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs index 8c94ef3f6c..7e8e197ea3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualOrderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThanOrEqualOrderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThanOrEqualOrderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThanOrEqualOrderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThanOrEqualOrderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThanOrEqualOrderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqualOrderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqualOrderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualOrderedScalarBoolean(); var result = Sse.CompareGreaterThanOrEqualOrderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThanOrEqualOrderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThanOrEqualOrderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs index 7a658989a4..d7993b3997 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThanOrEqualScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThanOrEqualScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThanOrEqualScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThanOrEqualScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThanOrEqualScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqualScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqualScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualScalarSingle(); var result = Sse.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThanOrEqualScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThanOrEqualScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs index 131b787836..e9558ef9da 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrEqualUnorderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThanOrEqualUnorderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThanOrEqualUnorderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThanOrEqualUnorderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThanOrEqualUnorderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareGreaterThanOrEqualUnorderedScalarBoolean(); var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThanOrEqualUnorderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs index 3ea4f89d96..20a7670b51 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanOrderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThanOrderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThanOrderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThanOrderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThanOrderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThanOrderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanOrderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareGreaterThanOrderedScalarBoolean(); var result = Sse.CompareGreaterThanOrderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThanOrderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThanOrderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs index 0a9ebb7a16..50ff5a8989 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThanScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThanScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThanScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThanScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThanScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanScalarSingle(); var result = Sse.CompareGreaterThanScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThanScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThanScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs index f59203e88f..5bfd3cd46f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareGreaterThanUnorderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareGreaterThanUnorderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareGreaterThanUnorderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareGreaterThanUnorderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareGreaterThanUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareGreaterThanUnorderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareGreaterThanUnorderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanUnorderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareGreaterThanUnorderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareGreaterThanUnorderedScalarBoolean(); var result = Sse.CompareGreaterThanUnorderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareGreaterThanUnorderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareGreaterThanUnorderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs index 89b58b83df..f2aaadebca 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThan.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThan( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThan( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanSingle(); var result = Sse.CompareLessThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs index 813f9a7372..a96162ed1c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqual.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThanOrEqual( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThanOrEqual( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanOrEqualSingle(); var result = Sse.CompareLessThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs index 4f40cf893c..361c43de61 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualOrderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThanOrEqualOrderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThanOrEqualOrderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThanOrEqualOrderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThanOrEqualOrderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThanOrEqualOrderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqualOrderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqualOrderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareLessThanOrEqualOrderedScalarBoolean(); var result = Sse.CompareLessThanOrEqualOrderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThanOrEqualOrderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThanOrEqualOrderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs index 1e8d99151d..abf85b16e6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThanOrEqualScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThanOrEqualScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThanOrEqualScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThanOrEqualScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThanOrEqualScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqualScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqualScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanOrEqualScalarSingle(); var result = Sse.CompareLessThanOrEqualScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThanOrEqualScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThanOrEqualScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs index 3a17770e70..8e497346d5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrEqualUnorderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThanOrEqualUnorderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThanOrEqualUnorderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThanOrEqualUnorderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThanOrEqualUnorderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThanOrEqualUnorderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqualUnorderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrEqualUnorderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareLessThanOrEqualUnorderedScalarBoolean(); var result = Sse.CompareLessThanOrEqualUnorderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThanOrEqualUnorderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThanOrEqualUnorderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs index b39cc9ff06..368e396594 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanOrderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThanOrderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThanOrderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThanOrderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThanOrderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThanOrderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanOrderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareLessThanOrderedScalarBoolean(); var result = Sse.CompareLessThanOrderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThanOrderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThanOrderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs index 269e807de1..d78bdb098f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThanScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThanScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThanScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThanScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThanScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanScalarSingle(); var result = Sse.CompareLessThanScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThanScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThanScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs index 2ae72ef346..d1e6a3c5bb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareLessThanUnorderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareLessThanUnorderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareLessThanUnorderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareLessThanUnorderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareLessThanUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareLessThanUnorderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareLessThanUnorderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanUnorderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareLessThanUnorderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareLessThanUnorderedScalarBoolean(); var result = Sse.CompareLessThanUnorderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareLessThanUnorderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareLessThanUnorderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs index 1fa307068a..a844414c38 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqual.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotEqual( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotEqual( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotEqualSingle(); var result = Sse.CompareNotEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs index 5e3d339b42..d98bf823b9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualOrderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotEqualOrderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotEqualOrderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotEqualOrderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotEqualOrderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotEqualOrderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqualOrderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqualOrderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareNotEqualOrderedScalarBoolean(); var result = Sse.CompareNotEqualOrderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotEqualOrderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotEqualOrderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs index 52db5986c6..d750f04ad4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotEqualScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotEqualScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotEqualScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotEqualScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotEqualScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqualScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqualScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotEqualScalarSingle(); var result = Sse.CompareNotEqualScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotEqualScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotEqualScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs index 2fdb19abbc..22fd0e3474 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotEqualUnorderedScalar.Boolean.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotEqualUnorderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotEqualUnorderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotEqualUnorderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -200,6 +208,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -211,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotEqualUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -222,6 +234,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotEqualUnorderedScalar( _clsVar1, _clsVar2 @@ -232,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotEqualUnorderedScalar(left, right); @@ -241,6 +257,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqualUnorderedScalar(left, right); @@ -250,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotEqualUnorderedScalar(left, right); @@ -259,6 +279,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanComparisonOpTest__CompareNotEqualUnorderedScalarBoolean(); var result = Sse.CompareNotEqualUnorderedScalar(test._fld1, test._fld2); @@ -267,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotEqualUnorderedScalar(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotEqualUnorderedScalar(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -281,12 +307,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs index d017500bcf..36a913d3d1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThan.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotGreaterThan( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotGreaterThan( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotGreaterThanSingle(); var result = Sse.CompareNotGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs index 2036fcadfe..dc33a3f645 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqual.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotGreaterThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotGreaterThanOrEqual( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotGreaterThanOrEqual( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotGreaterThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotGreaterThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualSingle(); var result = Sse.CompareNotGreaterThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotGreaterThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotGreaterThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs index 1b74155927..84353311b2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanOrEqualScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotGreaterThanOrEqualScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotGreaterThanOrEqualScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotGreaterThanOrEqualScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotGreaterThanOrEqualScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotGreaterThanOrEqualScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThanOrEqualScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThanOrEqualScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualScalarSingle(); var result = Sse.CompareNotGreaterThanOrEqualScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotGreaterThanOrEqualScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotGreaterThanOrEqualScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs index 3f4e618c5a..c2fe47d0d3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotGreaterThanScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotGreaterThanScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotGreaterThanScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotGreaterThanScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotGreaterThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotGreaterThanScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotGreaterThanScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThanScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotGreaterThanScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotGreaterThanScalarSingle(); var result = Sse.CompareNotGreaterThanScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotGreaterThanScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotGreaterThanScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs index e2d32f1982..69908e7c3b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThan.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotLessThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotLessThan( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotLessThan( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotLessThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotLessThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotLessThanSingle(); var result = Sse.CompareNotLessThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotLessThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotLessThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs index 3ac5860ed5..d9ef1f61ac 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqual.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotLessThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotLessThanOrEqual( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotLessThanOrEqual( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotLessThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotLessThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualSingle(); var result = Sse.CompareNotLessThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotLessThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotLessThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs index 8e9b066ba3..ad21caffcd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanOrEqualScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotLessThanOrEqualScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotLessThanOrEqualScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotLessThanOrEqualScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanOrEqualScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotLessThanOrEqualScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotLessThanOrEqualScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThanOrEqualScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThanOrEqualScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualScalarSingle(); var result = Sse.CompareNotLessThanOrEqualScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotLessThanOrEqualScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotLessThanOrEqualScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs index cb1e5a1731..22f62636f5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareNotLessThanScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareNotLessThanScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareNotLessThanScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareNotLessThanScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareNotLessThanScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareNotLessThanScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareNotLessThanScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThanScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareNotLessThanScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotLessThanScalarSingle(); var result = Sse.CompareNotLessThanScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareNotLessThanScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareNotLessThanScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs index 9a51a53cee..f280d6c653 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrdered.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareOrdered( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareOrdered( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareOrdered( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrdered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrdered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrdered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareOrdered( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareOrdered(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareOrdered(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareOrdered(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareOrderedSingle(); var result = Sse.CompareOrdered(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareOrdered(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareOrdered(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs index 766bf55999..cb66abcc15 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareOrderedScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareOrderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareOrderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareOrderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareOrderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareOrderedScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareOrderedScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareOrderedScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareOrderedScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareOrderedScalarSingle(); var result = Sse.CompareOrderedScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareOrderedScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareOrderedScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs index b3cd667c49..489e814039 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnordered.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareUnordered( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareUnordered( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareUnordered( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnordered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnordered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnordered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareUnordered( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareUnordered(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareUnordered(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareUnordered(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareUnorderedSingle(); var result = Sse.CompareUnordered(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareUnordered(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareUnordered(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs index 719e31509d..bb09a2237e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/CompareUnorderedScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.CompareUnorderedScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.CompareUnorderedScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.CompareUnorderedScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.CompareUnorderedScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.CompareUnorderedScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.CompareUnorderedScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareUnorderedScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.CompareUnorderedScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareUnorderedScalarSingle(); var result = Sse.CompareUnorderedScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.CompareUnorderedScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.CompareUnorderedScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs index 6bcdc0a9f4..0082ac1d3b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Divide.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Divide( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Divide( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Divide( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Divide), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Divide), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Divide), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Divide( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Divide(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Divide(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Divide(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__DivideSingle(); var result = Sse.Divide(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Divide(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Divide(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs index ba26bc7c79..17c55b1092 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/DivideScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.DivideScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.DivideScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.DivideScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.DivideScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.DivideScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.DivideScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.DivideScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.DivideScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.DivideScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.DivideScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__DivideScalarSingle(); var result = Sse.DivideScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.DivideScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.DivideScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs index 7c6d4a152b..e0c5cf51a3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Max.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Max( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Max( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxSingle(); var result = Sse.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs index e2b19b8ddf..308199cb26 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MaxScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.MaxScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.MaxScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.MaxScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.MaxScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.MaxScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.MaxScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.MaxScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.MaxScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.MaxScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.MaxScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxScalarSingle(); var result = Sse.MaxScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.MaxScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.MaxScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs index dae00893cd..e345a29ec9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Min.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Min( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Min( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinSingle(); var result = Sse.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs index 4f603ae8b2..ca351f7052 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MinScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.MinScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.MinScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.MinScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.MinScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.MinScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.MinScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.MinScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.MinScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.MinScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.MinScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinScalarSingle(); var result = Sse.MinScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.MinScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.MinScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs index b0ab8952dd..b683d0f430 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Multiply.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Multiply( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Multiply( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Multiply( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Multiply), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Multiply), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Multiply), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Multiply( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Multiply(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Multiply(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Multiply(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplySingle(); var result = Sse.Multiply(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Multiply(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Multiply(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs index 654a16a947..8f08242c23 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/MultiplyScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.MultiplyScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.MultiplyScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.MultiplyScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.MultiplyScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.MultiplyScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.MultiplyScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.MultiplyScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.MultiplyScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.MultiplyScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.MultiplyScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplyScalarSingle(); var result = Sse.MultiplyScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.MultiplyScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.MultiplyScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs index cdae4d58e1..fa6694a8ef 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Or.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Or( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Or( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrSingle(); var result = Sse.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs index 13f745191c..5c3f62321c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Subtract.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Subtract( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Subtract( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSingle(); var result = Sse.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs index 9eeb4b51a1..4825242823 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/SubtractScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.SubtractScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.SubtractScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.SubtractScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.SubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.SubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.SubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.SubtractScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.SubtractScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.SubtractScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.SubtractScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractScalarSingle(); var result = Sse.SubtractScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.SubtractScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.SubtractScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs index da6ccb87e2..edc9c3d697 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse/Xor.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse.Xor( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse.Xor( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse).GetMethod(nameof(Sse.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse).GetMethod(nameof(Sse.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse).GetMethod(nameof(Sse.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorSingle(); var result = Sse.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs index c97641f542..3c295d8962 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddByte(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs index 185b263b34..0f9c42781d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddDouble(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs index 5f3dc3fd80..9014ce29cb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddInt16(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs index 718ddff3ee..db6500b2da 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddInt32(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs index 46fc8cb310..5b370e6de1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddInt64(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs index e920b5a8c3..987b7f05cd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSByte(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs index c7dfbef767..7f71efbf08 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddUInt16(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs index 3b955439bf..c2b3aacf6d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddUInt32(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs index 71f3825944..4e1425aa68 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Add.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Add( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Add( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Add( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Add), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Add( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Add(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Add(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddUInt64(); var result = Sse2.Add(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Add(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Add(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs index 763f18f8ea..5a141b7fd1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AddSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AddSaturate( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AddSaturate( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AddSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AddSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.AddSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.AddSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSaturateByte(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AddSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs index cea585e248..c6344ab9dc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AddSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AddSaturate( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AddSaturate( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AddSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AddSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.AddSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.AddSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSaturateInt16(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AddSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs index 9136691953..2e0a9fc1f6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AddSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AddSaturate( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AddSaturate( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AddSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AddSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.AddSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.AddSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSaturateSByte(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AddSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs index 517802ff30..720ea465db 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddSaturate.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AddSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AddSaturate( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AddSaturate( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AddSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AddSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.AddSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.AddSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddSaturateUInt16(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AddSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AddSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs index e5fe7fa42c..da3fe49b08 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AddScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AddScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AddScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AddScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AddScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AddScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AddScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.AddScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.AddScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AddScalarDouble(); var result = Sse2.AddScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AddScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AddScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs index 4b00fa5077..16137651f8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndByte(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs index 89133cba07..5a4581e1f7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndDouble(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs index ed805c1f6f..6ead6c74b8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndInt16(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs index 3774059b31..2817ce82b8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndInt32(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs index dbcf9721ef..9186926feb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndInt64(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs index 51f5897386..4b51077cd0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndSByte(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs index f296099552..908c90425f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndUInt16(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs index 7a403e5b24..57c0d4ffb3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndUInt32(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs index 0cb7e3a821..4f3cea4a2f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/And.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.And( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.And( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.And( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.And), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.And( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.And(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.And(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndUInt64(); var result = Sse2.And(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.And(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.And(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs index a040532e07..8444aefaeb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotByte(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs index 1b1ca8fbee..2fe071b8ed 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotDouble(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs index 90e52c6e37..de6c7319ac 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotInt16(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs index d870b53e91..66596bffa2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotInt32(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs index f23f563bbf..8785930cd5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotInt64(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs index 13ae3c5cc6..8eab92caa6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotSByte(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs index 61dcf9b1ff..24e46a47f3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotUInt16(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs index a456d20693..83a5ee6b6c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotUInt32(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs index b42dca7eef..6c3eaed699 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/AndNot.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.AndNot( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.AndNot( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.AndNot( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.AndNot), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.AndNot( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.AndNot(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.AndNot(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AndNotUInt64(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.AndNot(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.AndNot(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs index 3743cf7914..ad2634a84e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Average( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Average( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Average( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Average), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Average), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Average), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Average( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Average(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Average(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Average(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AverageByte(); var result = Sse2.Average(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Average(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Average(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs index dd6b07dc4d..0af90e5494 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Average.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Average( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Average( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Average( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Average), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Average), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Average), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Average( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Average(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Average(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Average(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__AverageUInt16(); var result = Sse2.Average(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Average(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Average(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs index 42a4e5d6ff..054f42b83b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareEqual( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareEqual( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualByte(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs index dccc79b6dd..b2ee01b33f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareEqual( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareEqual( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualDouble(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs index 0000b64a61..d325b1ef1a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareEqual( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareEqual( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualInt16(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs index f7dcb14091..a7298a2155 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareEqual( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareEqual( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualInt32(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs index ccee8a492c..247079f507 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareEqual( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareEqual( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualSByte(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs index b690410bad..1dfc5cd242 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareEqual( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareEqual( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualUInt16(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs index 6e4eee4df4..4f5997723e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareEqual.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareEqual( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareEqual( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualUInt32(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs index fec68a311c..69e912cd15 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareGreaterThan( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareGreaterThan( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanDouble(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs index 31127aa2fa..90b1a278f1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareGreaterThan( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareGreaterThan( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanInt16(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs index b1a47057b1..98922609e1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareGreaterThan( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareGreaterThan( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanInt32(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs index a1a475f717..31ac233ea2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThan.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareGreaterThan( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareGreaterThan( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanSByte(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs index dd1a42ae93..9f7a27027b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareGreaterThanOrEqual.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareGreaterThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareGreaterThanOrEqual( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareGreaterThanOrEqual( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareGreaterThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareGreaterThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareGreaterThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanOrEqualDouble(); var result = Sse2.CompareGreaterThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareGreaterThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareGreaterThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs index 6b3b870c18..47cf824528 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareLessThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareLessThan( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareLessThan( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareLessThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareLessThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanDouble(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareLessThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs index ac9113f4e0..ed88d91e2a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareLessThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareLessThan( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareLessThan( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareLessThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareLessThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanInt16(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareLessThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs index ed1170fe28..c784dcf02d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareLessThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareLessThan( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareLessThan( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareLessThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareLessThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanInt32(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareLessThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs index f44b733bc3..5891189795 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThan.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareLessThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareLessThan( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareLessThan( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareLessThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareLessThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanSByte(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareLessThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareLessThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs index 95c5a35626..e15d4fb57d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareLessThanOrEqual.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareLessThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareLessThanOrEqual( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareLessThanOrEqual( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareLessThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareLessThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareLessThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareLessThanOrEqualDouble(); var result = Sse2.CompareLessThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareLessThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareLessThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs index 7623ebeb6b..3350852bc4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotEqual.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareNotEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareNotEqual( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareNotEqual( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareNotEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareNotEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotEqualDouble(); var result = Sse2.CompareNotEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareNotEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareNotEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs index 3134235db7..84eb237725 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThan.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareNotGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareNotGreaterThan( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareNotGreaterThan( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareNotGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareNotGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotGreaterThanDouble(); var result = Sse2.CompareNotGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareNotGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareNotGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs index 819e876b1f..a9fc74b6b5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotGreaterThanOrEqual.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareNotGreaterThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareNotGreaterThanOrEqual( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareNotGreaterThanOrEqual( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotGreaterThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareNotGreaterThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareNotGreaterThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotGreaterThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotGreaterThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotGreaterThanOrEqualDouble(); var result = Sse2.CompareNotGreaterThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareNotGreaterThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareNotGreaterThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs index 8a91ec289a..afb0af16dc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThan.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareNotLessThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareNotLessThan( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareNotLessThan( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareNotLessThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareNotLessThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotLessThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotLessThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotLessThanDouble(); var result = Sse2.CompareNotLessThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareNotLessThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareNotLessThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs index fa33e7e5ae..f5263fd0eb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareNotLessThanOrEqual.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareNotLessThanOrEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareNotLessThanOrEqual( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareNotLessThanOrEqual( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareNotLessThanOrEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareNotLessThanOrEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareNotLessThanOrEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotLessThanOrEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareNotLessThanOrEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareNotLessThanOrEqualDouble(); var result = Sse2.CompareNotLessThanOrEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareNotLessThanOrEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareNotLessThanOrEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs index ea1f2aa111..64efe0ef97 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareOrdered.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareOrdered( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareOrdered( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareOrdered( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareOrdered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareOrdered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareOrdered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareOrdered( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareOrdered(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareOrdered(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareOrdered(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareOrderedDouble(); var result = Sse2.CompareOrdered(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareOrdered(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareOrdered(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs index 768fdb9ccd..2104b3d548 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/CompareUnordered.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.CompareUnordered( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.CompareUnordered( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.CompareUnordered( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareUnordered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareUnordered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.CompareUnordered), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.CompareUnordered( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.CompareUnordered(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareUnordered(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.CompareUnordered(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareUnorderedDouble(); var result = Sse2.CompareUnordered(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.CompareUnordered(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.CompareUnordered(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs index cfb46d3f62..96e00c175e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Divide.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Divide( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Divide( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Divide( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Divide), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Divide), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Divide), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Divide( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Divide(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Divide(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Divide(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__DivideDouble(); var result = Sse2.Divide(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Divide(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Divide(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs index c5d8a59cf6..e5203f5332 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/DivideScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.DivideScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.DivideScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.DivideScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.DivideScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.DivideScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.DivideScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.DivideScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.DivideScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.DivideScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.DivideScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__DivideScalarDouble(); var result = Sse2.DivideScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.DivideScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.DivideScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs index 01655ed6d8..5391bbdaaf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Extract( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Extract( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt161(); var result = Sse2.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs index 201c6bea8c..77669cfe3b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Extract.UInt16.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 129 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Extract( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 129 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Extract( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 129 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Extract( _clsVar, 129 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.Extract(firstOp, 129); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Extract(firstOp, 129); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Extract(firstOp, 129); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt16129(); var result = Sse2.Extract(test._fld, 129); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Extract(_fld, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Extract(test._fld, 129); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs index 496e77a2bb..7a3b2af433 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (short)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Insert( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Insert( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Insert( _clsVar, (short)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.Insert(firstOp, (short)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (short)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (short)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt161(); var result = Sse2.Insert(test._fld, (short)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Insert(_fld, (short)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Insert(test._fld, (short)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs index a1dcb90c5b..8741db933a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.Int16.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (short)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Insert( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Insert( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), (short)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(Int16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Insert( _clsVar, (short)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.Insert(firstOp, (short)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (short)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (short)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt16129(); var result = Sse2.Insert(test._fld, (short)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Insert(_fld, (short)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Insert(test._fld, (short)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs index ab53e07180..9e105f5a5d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ushort)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Insert( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Insert( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Insert( _clsVar, (ushort)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.Insert(firstOp, (ushort)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (ushort)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (ushort)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt161(); var result = Sse2.Insert(test._fld, (ushort)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Insert(_fld, (ushort)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Insert(test._fld, (ushort)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs index bf6c40c640..afc53688bf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Insert.UInt16.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ushort)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Insert( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Insert( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), (ushort)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Insert), new Type[] { typeof(Vector128), typeof(UInt16), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Insert( _clsVar, (ushort)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.Insert(firstOp, (ushort)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (ushort)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.Insert(firstOp, (ushort)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt16129(); var result = Sse2.Insert(test._fld, (ushort)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Insert(_fld, (ushort)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Insert(test._fld, (ushort)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs index 3c7e4d8862..bd7cc51328 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Max( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Max( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxByte(); var result = Sse2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs index c74288efb2..821376a3d1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Max( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Max( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxDouble(); var result = Sse2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs index d48393f047..c0a08d7e72 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Max.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Max( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Max( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxInt16(); var result = Sse2.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs index af585911a0..90b776da7d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MaxScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.MaxScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.MaxScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.MaxScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MaxScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MaxScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MaxScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.MaxScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.MaxScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.MaxScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.MaxScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxScalarDouble(); var result = Sse2.MaxScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.MaxScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.MaxScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs index 69cd5fc07d..b2d1d4b8f4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Min( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Min( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinByte(); var result = Sse2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs index cbdca42cb4..8e72d20b6e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Min( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Min( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinDouble(); var result = Sse2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs index 327fa5cbb0..89e2d3e503 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Min.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Min( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Min( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinInt16(); var result = Sse2.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs index 001d2d1a2b..d391ceeeff 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MinScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.MinScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.MinScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.MinScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MinScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MinScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MinScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.MinScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.MinScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.MinScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.MinScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinScalarDouble(); var result = Sse2.MinScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.MinScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.MinScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs index c0db478fcd..46008a34f9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Multiply.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Multiply( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Multiply( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Multiply( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Multiply), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Multiply), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Multiply), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Multiply( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Multiply(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Multiply(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Multiply(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplyDouble(); var result = Sse2.Multiply(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Multiply(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Multiply(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs index dfa41dcf74..104eb932d9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/MultiplyScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.MultiplyScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.MultiplyScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.MultiplyScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MultiplyScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MultiplyScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.MultiplyScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.MultiplyScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.MultiplyScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.MultiplyScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.MultiplyScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplyScalarDouble(); var result = Sse2.MultiplyScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.MultiplyScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.MultiplyScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs index 09745f6fa4..62a9e6dcb5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrByte(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs index 822281d1e3..c6ba468e8e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrDouble(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs index 18f6974116..28b5033fec 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrInt16(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs index 64aa8c3afa..0fa0516376 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrInt32(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs index 40d810066b..54863530d3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrInt64(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs index 39005e2b08..2cb83a6ddb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrSByte(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs index 1b2f94808c..fa654a1cfb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrUInt16(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs index edfb251575..1079557465 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrUInt32(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs index 3d60b6686a..7fe77056bb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Or.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Or( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Or( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Or( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Or), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Or( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Or(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Or(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__OrUInt64(); var result = Sse2.Or(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Or(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Or(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Byte.cs index 2ff76f677d..8357bb23ea 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Byte.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(Byte) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128Byte(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Double.cs index e2ccd4661b..ed8e7d9376 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Double.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(Double) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128Double(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int16.cs index 5cfa504732..d8965df10e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int16.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(Int16) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128Int16(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int32.cs index 60482f2fe4..388cd57ee7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int32.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(Int32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128Int32(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int64.cs index 747c70a6ac..1969539db6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.Int64.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(Int64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128Int64(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.SByte.cs index 7ac3a50c75..094e097466 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.SByte.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(SByte) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128SByte(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt16.cs index fc8d0d6b29..118560b740 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt16.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(UInt16) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128UInt16(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt32.cs index 32702bf9ba..1aeaccaa32 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt32.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(UInt32) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128UInt32(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt64.cs index 159eb04e8a..333d556eac 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SetAllVector128.UInt64.cs @@ -117,6 +117,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SetAllVector128( Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) ); @@ -127,6 +129,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SetAllVector128), new Type[] { typeof(UInt64) }) .Invoke(null, new object[] { Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)) @@ -138,6 +142,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SetAllVector128( _clsVar ); @@ -148,6 +154,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var data = Unsafe.ReadUnaligned(ref Unsafe.As(ref _data)); var result = Sse2.SetAllVector128(data); @@ -157,6 +165,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ScalarSimdUnaryOpTest__SetAllVector128UInt64(); var result = Sse2.SetAllVector128(test._fld); @@ -166,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SetAllVector128(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -174,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SetAllVector128(test._fld); @@ -183,12 +197,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs index 77753514b3..78d5b34bb4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt161(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs index dcffdaf356..237ca7d72a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt1616(); var result = Sse2.ShiftLeftLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs index 10465003b3..b3c70c5027 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt321(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs index d0f5c6e4fe..24f74e7057 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt3232(); var result = Sse2.ShiftLeftLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs index 2d5e560900..f0747c9207 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt641(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs index 35e4ed2c8d..ba3f39c271 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.Int64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalInt6464(); var result = Sse2.ShiftLeftLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs index 02de439581..04338cac54 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt161(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs index e961582e4f..e10bdf5b34 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt1616(); var result = Sse2.ShiftLeftLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs index 489776cbed..a4a292767c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt321(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs index dd8b67d9c9..cb60ed5f8e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt3232(); var result = Sse2.ShiftLeftLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs index 5d52c51ac5..902b3a8a5e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt641(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs index df3926b32c..43ea12ecde 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical.UInt64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogicalUInt6464(); var result = Sse2.ShiftLeftLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs index 0750c6a4e7..dcd9a38dbb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneByte1(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs index 0dfb57d2d5..aefbcfeb4d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneInt161(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs index 82cc098c37..5c34dc0e0b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneInt321(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs index 67c73f8a0a..6eec46d66b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneInt641(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs index 258c44458c..52f5939f08 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.SByte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneSByte1(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs index aa2ca91bbd..5c328404fe 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneUInt161(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs index 13860d4a41..6c188673eb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneUInt321(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs index 38ce681ce1..514c7c7f67 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftLeftLogical128BitLane.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftLeftLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftLeftLogical128BitLane( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftLeftLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftLeftLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftLeftLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftLeftLogical128BitLaneUInt641(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftLeftLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftLeftLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs index dab1df06f3..3e91100014 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightArithmetic( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightArithmetic(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt161(); var result = Sse2.ShiftRightArithmetic(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightArithmetic(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightArithmetic(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs index 16a3ea0ddb..90676a2596 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightArithmetic( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightArithmetic(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt1616(); var result = Sse2.ShiftRightArithmetic(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightArithmetic(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightArithmetic(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs index 88b57c6d8d..eb4bc0e6e5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightArithmetic( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightArithmetic(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt321(); var result = Sse2.ShiftRightArithmetic(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightArithmetic(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightArithmetic(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs index b114cd68f6..8d7c25184f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightArithmetic.Int32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightArithmetic( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightArithmetic( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightArithmetic), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightArithmetic( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightArithmetic(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightArithmetic(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightArithmeticInt3232(); var result = Sse2.ShiftRightArithmetic(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightArithmetic(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightArithmetic(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs index 7abba5d928..4b0536af3f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt161(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs index 69376a9812..3d46689e92 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt1616(); var result = Sse2.ShiftRightLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs index 38e54c7b3d..688900b4b9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt321(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs index 07e29e6e98..6e274602de 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt3232(); var result = Sse2.ShiftRightLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs index 06acadf1eb..4a1bfefe48 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt641(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs index 30d8ce27a1..ba7aaa7931 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.Int64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalInt6464(); var result = Sse2.ShiftRightLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs index 404a14879e..6a434559dc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt161(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs index 64b95247fa..59b3c4abcc 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt16.16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 16 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 16 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 16 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 16); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 16); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 16); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt1616(); var result = Sse2.ShiftRightLogical(test._fld, 16); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 16); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs index a01b4f98b9..a442e1051d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt321(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs index 16f3f2de84..d3040c6966 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt32.32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 32 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 32 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 32 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 32); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 32); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 32); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt3232(); var result = Sse2.ShiftRightLogical(test._fld, 32); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 32); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs index b041ad5cf1..0897095e8f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt641(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs index 83ce45feec..466e3c4ad1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical.UInt64.64.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical( Unsafe.Read>(_dataTable.inArrayPtr), 64 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 64 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical( _clsVar, 64 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical(firstOp, 64); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 64); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical(firstOp, 64); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogicalUInt6464(); var result = Sse2.ShiftRightLogical(test._fld, 64); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical(_fld, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical(test._fld, 64); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs index 1463f54b77..6f49c9600a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneByte1(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs index b3c2e4972a..0999efde88 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneInt161(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs index 6ca2ea290e..f65579d4b2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneInt321(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs index 125abd815d..5300e80aff 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneInt641(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs index 63c7010ef0..033323bbed 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.SByte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneSByte1(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs index 2998ae0318..680413d1f3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt16.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneUInt161(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs index ee27c53acb..77522787bf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneUInt321(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs index 3845732e89..d82937e10f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/ShiftRightLogical128BitLane.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.ShiftRightLogical128BitLane( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.ShiftRightLogical128BitLane( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.ShiftRightLogical128BitLane), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.ShiftRightLogical128BitLane( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse2.ShiftRightLogical128BitLane(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ImmUnaryOpTest__ShiftRightLogical128BitLaneUInt641(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.ShiftRightLogical128BitLane(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.ShiftRightLogical128BitLane(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs index aaced393e0..559c2d96ec 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractByte(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs index 4635c299f2..589e570478 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractDouble(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs index 3200eac6e0..0680a1d76a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractInt16(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs index dd74d58c25..db266d83e3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractInt32(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs index a3ab26c961..0267313819 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractInt64(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs index 3ff24e74df..a966a586a1 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSByte(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs index 3228b4fa92..bc33d61135 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractUInt16(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs index 9bb733333c..2f1e8d3d69 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractUInt32(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs index 61b3e926c9..775fee3b4e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Subtract.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Subtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Subtract( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Subtract( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Subtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Subtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Subtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Subtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractUInt64(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Subtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Subtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs index 621543ddd5..90b403d157 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SubtractSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.SubtractSaturate( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.SubtractSaturate( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SubtractSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.SubtractSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSaturateByte(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SubtractSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs index 4a80eaf598..480dc062f4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SubtractSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.SubtractSaturate( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.SubtractSaturate( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SubtractSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.SubtractSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSaturateInt16(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SubtractSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs index 45e38a395a..e7838d0ac3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SubtractSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.SubtractSaturate( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.SubtractSaturate( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SubtractSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.SubtractSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSaturateSByte(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SubtractSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs index 058542a162..7f40054712 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractSaturate.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SubtractSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.SubtractSaturate( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.SubtractSaturate( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SubtractSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.SubtractSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.SubtractSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.SubtractSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractSaturateUInt16(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SubtractSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SubtractSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs index dead13941a..363d46d8f5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/SubtractScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.SubtractScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.SubtractScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.SubtractScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.SubtractScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.SubtractScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.SubtractScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.SubtractScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SubtractScalarDouble(); var result = Sse2.SubtractScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.SubtractScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.SubtractScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs index 8ce37a33a1..b5e4e8556b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorByte(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs index 9517421076..2212c2474e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorDouble(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs index f147c6b63a..78a4881ae3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorInt16(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs index dd8a52b8bc..3e54a28b6a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorInt32(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs index 3088b0a4bd..859aab8d0e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorInt64(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs index 4bb5dfb785..685a96c458 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorSByte(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs index 19c600a9b7..13cde1910e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorUInt16(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs index ca802351e0..11fc8addde 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorUInt32(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs index bb5a8b3fff..fff6e3efb9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse2/Xor.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse2.Xor( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse2.Xor( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse2.Xor( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse2).GetMethod(nameof(Sse2.Xor), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse2.Xor( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse2.Xor(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse2.Xor(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__XorUInt64(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse2.Xor(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse2.Xor(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs index f666d5339d..4044a273cd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse3.AddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse3.AddSubtract( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse3.AddSubtract( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.AddSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.AddSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.AddSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse3.AddSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse3.AddSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse3.AddSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse3.AddSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingBinaryOpTest__AddSubtractDouble(); var result = Sse3.AddSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse3.AddSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse3.AddSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs index deb19bb7a3..3020220b3b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/AddSubtract.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse3.AddSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse3.AddSubtract( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse3.AddSubtract( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.AddSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.AddSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.AddSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse3.AddSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse3.AddSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse3.AddSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse3.AddSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new AlternatingBinaryOpTest__AddSubtractSingle(); var result = Sse3.AddSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse3.AddSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse3.AddSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs index 3e44d5aec2..206c2678a2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse3.HorizontalAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse3.HorizontalAdd( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse3.HorizontalAdd( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse3.HorizontalAdd( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse3.HorizontalAdd(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalAdd(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalAdd(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalAddDouble(); var result = Sse3.HorizontalAdd(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse3.HorizontalAdd(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse3.HorizontalAdd(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs index 9d00ff931f..a28c1b97d6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalAdd.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse3.HorizontalAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse3.HorizontalAdd( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse3.HorizontalAdd( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse3.HorizontalAdd( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse3.HorizontalAdd(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalAdd(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalAdd(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalAddSingle(); var result = Sse3.HorizontalAdd(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse3.HorizontalAdd(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse3.HorizontalAdd(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs index db2cea3a6c..4629c3ba27 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse3.HorizontalSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse3.HorizontalSubtract( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse3.HorizontalSubtract( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse3.HorizontalSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse3.HorizontalSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalSubtractDouble(); var result = Sse3.HorizontalSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse3.HorizontalSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse3.HorizontalSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs index 05ec132713..25ad60b6bf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse3/HorizontalSubtract.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse3.HorizontalSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse3.HorizontalSubtract( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse3.HorizontalSubtract( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse3).GetMethod(nameof(Sse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse3.HorizontalSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse3.HorizontalSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse3.HorizontalSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalSubtractSingle(); var result = Sse3.HorizontalSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse3.HorizontalSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse3.HorizontalSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs index 1783b1dec0..eedee7d643 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Byte.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.BlendVariable( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.BlendVariable( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Byte*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableByte(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs index 602a06bb6f..c724110844 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Double.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.BlendVariable( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.BlendVariable( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((Double*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableDouble(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs index 39695574cc..88204104a2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.SByte.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.BlendVariable( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.BlendVariable( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadVector128((SByte*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var secondOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var thirdOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableSByte(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs index 573956b972..e0ec36d59e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/BlendVariable.Single.cs @@ -174,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.BlendVariable( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -186,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.BlendVariable( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -198,6 +202,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.BlendVariable( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -210,6 +216,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -223,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -236,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.BlendVariable), new Type[] { typeof(Vector128), typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -249,6 +261,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.BlendVariable( _clsVar1, _clsVar2, @@ -261,6 +275,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArray1Ptr); var secondOp = Unsafe.Read>(_dataTable.inArray2Ptr); var thirdOp = Unsafe.Read>(_dataTable.inArray3Ptr); @@ -272,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadVector128((Single*)(_dataTable.inArray3Ptr)); @@ -283,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var secondOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var thirdOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray3Ptr)); @@ -294,6 +314,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleTernaryOpTest__BlendVariableSingle(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -303,6 +325,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.BlendVariable(_fld1, _fld2, _fld3); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -311,6 +335,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.BlendVariable(test._fld1, test._fld2, test._fld3); @@ -320,12 +346,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs index 004de3e678..48f534a036 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Ceiling( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Ceiling( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Ceiling( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Ceiling), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Ceiling), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Ceiling), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Ceiling( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Ceiling(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.Ceiling(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.Ceiling(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__CeilingDouble(); var result = Sse41.Ceiling(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Ceiling(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Ceiling(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs index 9093d1e878..0a512713c3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Ceiling.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Ceiling( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Ceiling( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Ceiling( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Ceiling), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Ceiling), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Ceiling), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Ceiling( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Ceiling(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Ceiling(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Ceiling(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__CeilingSingle(); var result = Sse41.Ceiling(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Ceiling(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Ceiling(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs index 0764e9f58f..6584b85613 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.CeilingScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.CeilingScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.CeilingScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CeilingScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CeilingScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CeilingScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.CeilingScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.CeilingScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.CeilingScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.CeilingScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CeilingScalarDouble(); var result = Sse41.CeilingScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.CeilingScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.CeilingScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs index 39b6fa09e9..5677da3a3d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CeilingScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.CeilingScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.CeilingScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.CeilingScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CeilingScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CeilingScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CeilingScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.CeilingScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.CeilingScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.CeilingScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.CeilingScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CeilingScalarSingle(); var result = Sse41.CeilingScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.CeilingScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.CeilingScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs index 49efddd15c..05998d2e6a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.CompareEqual( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.CompareEqual( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualInt64(); var result = Sse41.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs index 8181abb746..02259e154e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/CompareEqual.UInt64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.CompareEqual( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.CompareEqual( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.CompareEqual( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.CompareEqual), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.CompareEqual( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.CompareEqual(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.CompareEqual(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.CompareEqual(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareEqualUInt64(); var result = Sse41.CompareEqual(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.CompareEqual(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.CompareEqual(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs index 7077bfbb0d..45012f8ba9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractByte1(); var result = Sse41.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs index 64e3fd3541..ae32f5c08b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Byte.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 129 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), 129 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), 129 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 129 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 129); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractByte129(); var result = Sse41.Extract(test._fld, 129); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 129); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs index 59019ae96c..7e59d0e6fa 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt321(); var result = Sse41.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs index 77fac2e0d4..92b4fc6000 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int32.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 129 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), 129 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), 129 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 129 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 129); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt32129(); var result = Sse41.Extract(test._fld, 129); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 129); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs index 3d554c6ac2..903598d58c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt641(); var result = Sse41.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs index 3949c631c9..12685b1b1d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Int64.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 129 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), 129 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), 129 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 129 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 129); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractInt64129(); var result = Sse41.Extract(test._fld, 129); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 129); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs index ce21f4804f..0fa3b98455 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractSingle1(); var result = Sse41.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs index b889075ff2..a1fc3ac6d9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.Single.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 129 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)), 129 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)), 129 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 129 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 129); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractSingle129(); var result = Sse41.Extract(test._fld, 129); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 129); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs index e2a9b5f4d2..65db7dd2cf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt321(); var result = Sse41.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs index e54387d8d4..b77c4b2fb9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt32.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 129 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), 129 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), 129 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 129 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 129); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt32129(); var result = Sse41.Extract(test._fld, 129); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 129); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs index 0a6eaaf56c..0e3c6f6abd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 1 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 1 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 1 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 1); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 1); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt641(); var result = Sse41.Extract(test._fld, 1); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 1); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs index 64a5e13ccd..90e414c7f7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Extract.UInt64.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Extract( Unsafe.Read>(_dataTable.inArrayPtr), 129 @@ -161,6 +163,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Extract( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), 129 @@ -172,6 +176,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Extract( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), 129 @@ -183,6 +189,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -195,6 +203,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -207,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Extract), new Type[] { typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -219,6 +231,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Extract( _clsVar, 129 @@ -230,6 +244,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Extract(firstOp, 129); @@ -239,6 +255,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -248,6 +266,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Extract(firstOp, 129); @@ -257,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new ExtractScalarTest__ExtractUInt64129(); var result = Sse41.Extract(test._fld, 129); @@ -266,6 +288,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Extract(_fld, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -274,6 +298,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Extract(test._fld, 129); @@ -283,12 +309,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs index 87686057c6..03800e68ab 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Floor( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Floor( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Floor( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Floor), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Floor), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Floor), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Floor( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Floor(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.Floor(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.Floor(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__FloorDouble(); var result = Sse41.Floor(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Floor(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Floor(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs index 64c7d06eb3..e9483f3ffd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Floor.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Floor( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Floor( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Floor( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Floor), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Floor), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Floor), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Floor( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Floor(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Floor(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.Floor(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__FloorSingle(); var result = Sse41.Floor(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Floor(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Floor(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs index a4365d8998..7859b50c70 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.FloorScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.FloorScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.FloorScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.FloorScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.FloorScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.FloorScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.FloorScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.FloorScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.FloorScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.FloorScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__FloorScalarDouble(); var result = Sse41.FloorScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.FloorScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.FloorScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs index 8bde1b4587..d41aa62c21 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/FloorScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.FloorScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.FloorScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.FloorScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.FloorScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.FloorScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.FloorScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.FloorScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.FloorScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.FloorScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.FloorScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__FloorScalarSingle(); var result = Sse41.FloorScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.FloorScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.FloorScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs index 007dc1f5d4..1087ce7d97 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (byte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (byte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (byte)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (byte)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (byte)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertByte1(); var result = Sse41.Insert(test._fld, (byte)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (byte)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (byte)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs index c7132df23a..5335b1ac5a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Byte.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (byte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), (byte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Byte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (byte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (byte)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (byte)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (byte)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertByte129(); var result = Sse41.Insert(test._fld, (byte)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (byte)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (byte)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs index d81df1e33b..e4d82ca531 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (int)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (int)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (int)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (int)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (int)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt321(); var result = Sse41.Insert(test._fld, (int)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (int)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (int)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs index 44a7e9d9a4..6d27eb8a46 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int32.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (int)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), (int)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (int)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (int)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (int)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (int)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt32129(); var result = Sse41.Insert(test._fld, (int)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (int)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (int)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs index f10d59a1d9..cb25791cf3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (long)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (long)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (long)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (long)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (long)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt641(); var result = Sse41.Insert(test._fld, (long)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (long)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (long)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs index 674c5c91c0..4a33dcd8c7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Int64.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (long)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), (long)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Int64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (long)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (long)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (long)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (long)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertInt64129(); var result = Sse41.Insert(test._fld, (long)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (long)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (long)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs index 8f5606c2f5..be32281e14 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (sbyte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (sbyte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (sbyte)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (sbyte)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (sbyte)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertSByte1(); var result = Sse41.Insert(test._fld, (sbyte)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (sbyte)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (sbyte)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs index eedec97ba6..1cf7e01015 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.SByte.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (sbyte)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), (sbyte)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(SByte), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (sbyte)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (sbyte)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (sbyte)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (sbyte)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertSByte129(); var result = Sse41.Insert(test._fld, (sbyte)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (sbyte)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (sbyte)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs index 633a333926..a46bf18f5f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.0.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 0); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 0); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 0); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle0(); var result = Sse41.Insert(test._fld1, test._fld2, 0); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 0); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 0); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs index a41cfceab1..b8a9206b0e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.1.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 1); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 1); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 1); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle1(); var result = Sse41.Insert(test._fld1, test._fld2, 1); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 1); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs index da739652c6..a364316ce4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.128.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 128); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 128); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 128); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle128(); var result = Sse41.Insert(test._fld1, test._fld2, 128); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 128); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 128); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs index fede1c511e..79ce9a060a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.129.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 129); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 129); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 129); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle129(); var result = Sse41.Insert(test._fld1, test._fld2, 129); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 129); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs index d6ce59a9f9..bd089e027c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.16.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 16); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 16); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 16); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle16(); var result = Sse41.Insert(test._fld1, test._fld2, 16); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 16); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 16); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs index 0279bf3d5b..ea9988b005 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.192.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 192); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 192); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 192); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle192(); var result = Sse41.Insert(test._fld1, test._fld2, 192); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 192); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 192); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs index 85575954fb..8c4bc8c782 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.2.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 2); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 2); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 2); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle2(); var result = Sse41.Insert(test._fld1, test._fld2, 2); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 2); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs index 65918291cb..d76b950686 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.32.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 32); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 32); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 32); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle32(); var result = Sse41.Insert(test._fld1, test._fld2, 32); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 32); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 32); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs index 30f100d69e..6b96fb0a5a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.4.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 4); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 4); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 4); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle4(); var result = Sse41.Insert(test._fld1, test._fld2, 4); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 4); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 4); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs index 44e034d9d4..cd68b174a7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.48.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 48); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 48); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 48); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle48(); var result = Sse41.Insert(test._fld1, test._fld2, 48); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 48); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 48); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs index f5b1fbba4e..382a18a477 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.64.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 64); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 64); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 64); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle64(); var result = Sse41.Insert(test._fld1, test._fld2, 64); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 64); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 64); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs index 11df841383..3053772825 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.Single.8.cs @@ -164,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr), @@ -176,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), LoadVector128((Single*)(_dataTable.inArray2Ptr)), @@ -188,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)), @@ -200,6 +206,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -213,6 +221,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -226,6 +236,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(Vector128), typeof(byte) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -239,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar1, _clsVar2, @@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Insert(left, right, 8); @@ -261,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 8); @@ -271,6 +289,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.Insert(left, right, 8); @@ -281,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertVector128Test__InsertSingle8(); var result = Sse41.Insert(test._fld1, test._fld2, 8); @@ -290,6 +312,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld1, _fld2, 8); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -298,6 +322,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld1, test._fld2, 8); @@ -307,12 +333,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs index ac9cefd16d..ded030b1fd 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (uint)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (uint)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (uint)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (uint)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (uint)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt321(); var result = Sse41.Insert(test._fld, (uint)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (uint)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (uint)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs index ce88da403d..a68b779db9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt32.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (uint)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), (uint)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt32), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (uint)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (uint)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (uint)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (uint)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt32129(); var result = Sse41.Insert(test._fld, (uint)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (uint)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (uint)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs index fb0b7f62c7..dab352f515 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.1.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ulong)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (ulong)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (ulong)2, 1); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (ulong)2, 1); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (ulong)2, 1); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt641(); var result = Sse41.Insert(test._fld, (ulong)2, 1); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (ulong)2, 1); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (ulong)2, 1); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs index d610ec8eb1..cedeaa7fa6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Insert.UInt64.129.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Insert( Unsafe.Read>(_dataTable.inArrayPtr), (ulong)2, @@ -162,6 +164,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Insert( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -174,6 +178,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Insert( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), (ulong)2, @@ -186,6 +192,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr), @@ -199,6 +207,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -212,6 +222,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Insert), new Type[] { typeof(Vector128), typeof(UInt64), typeof(byte) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)), @@ -225,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Insert( _clsVar, (ulong)2, @@ -237,6 +251,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.Insert(firstOp, (ulong)2, 129); @@ -246,6 +262,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (ulong)2, 129); @@ -255,6 +273,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.Insert(firstOp, (ulong)2, 129); @@ -264,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new InsertScalarTest__InsertUInt64129(); var result = Sse41.Insert(test._fld, (ulong)2, 129); @@ -273,6 +295,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Insert(_fld, (ulong)2, 129); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -281,6 +305,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Insert(test._fld, (ulong)2, 129); @@ -290,12 +316,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs index a18edbcef2..fc0a6d5213 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Max( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Max( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxInt32(); var result = Sse41.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs index 8ae64d6e7d..e6e2fa0b6a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Max( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Max( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxSByte(); var result = Sse41.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs index ab9621a258..3d53ca2df5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Max( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Max( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxUInt16(); var result = Sse41.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs index 3874c7819e..0acb5d9364 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Max.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Max( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Max( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Max( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Max), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Max( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Max(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.Max(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.Max(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MaxUInt32(); var result = Sse41.Max(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Max(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Max(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs index 058cfd93a7..ee393d9e78 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Min( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Min( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinInt32(); var result = Sse41.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs index 8d5ef83ebe..cd5a0c4637 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Min( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Min( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinSByte(); var result = Sse41.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs index d5da14c3b2..85224f55fb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Min( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Min( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinUInt16(); var result = Sse41.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs index b6fc5e5121..2af6faf99f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/Min.UInt32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.Min( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.Min( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.Min( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.Min), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.Min( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.Min(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.Min(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.Min(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MinUInt32(); var result = Sse41.Min(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.Min(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.Min(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs index 53f773730f..b7cc73c852 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/MultiplyLow.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.MultiplyLow( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.MultiplyLow( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.MultiplyLow( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.MultiplyLow), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.MultiplyLow), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.MultiplyLow), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.MultiplyLow( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.MultiplyLow(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.MultiplyLow(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.MultiplyLow(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplyLowInt32(); var result = Sse41.MultiplyLow(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.MultiplyLow(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.MultiplyLow(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs index 80e5a5ec26..1c11dc9be2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/PackUnsignedSaturate.UInt16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.PackUnsignedSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.PackUnsignedSaturate( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.PackUnsignedSaturate( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.PackUnsignedSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.PackUnsignedSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.PackUnsignedSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.PackUnsignedSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.PackUnsignedSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.PackUnsignedSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.PackUnsignedSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__PackUnsignedSaturateUInt16(); var result = Sse41.PackUnsignedSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.PackUnsignedSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.PackUnsignedSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs index 075a75dcb8..a0e3717ae7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundCurrentDirection( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundCurrentDirection( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundCurrentDirection( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirection), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirection), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirection), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundCurrentDirection( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundCurrentDirection(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundCurrentDirection(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundCurrentDirection(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundCurrentDirectionDouble(); var result = Sse41.RoundCurrentDirection(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundCurrentDirection(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundCurrentDirection(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs index cc848a0377..5f071fa6f2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirection.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundCurrentDirection( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundCurrentDirection( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundCurrentDirection( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirection), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirection), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirection), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundCurrentDirection( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundCurrentDirection(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundCurrentDirection(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundCurrentDirection(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundCurrentDirectionSingle(); var result = Sse41.RoundCurrentDirection(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundCurrentDirection(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundCurrentDirection(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs index f270483ecd..31b41fe566 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundCurrentDirectionScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundCurrentDirectionScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundCurrentDirectionScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirectionScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirectionScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirectionScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundCurrentDirectionScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundCurrentDirectionScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundCurrentDirectionScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundCurrentDirectionScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundCurrentDirectionScalarDouble(); var result = Sse41.RoundCurrentDirectionScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundCurrentDirectionScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundCurrentDirectionScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs index 2bf63fa852..3db3c9e02b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundCurrentDirectionScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundCurrentDirectionScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundCurrentDirectionScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundCurrentDirectionScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirectionScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirectionScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundCurrentDirectionScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundCurrentDirectionScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundCurrentDirectionScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundCurrentDirectionScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundCurrentDirectionScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundCurrentDirectionScalarSingle(); var result = Sse41.RoundCurrentDirectionScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundCurrentDirectionScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundCurrentDirectionScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs index ec8369cce8..690e9c6bf5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNearestInteger( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNearestInteger( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNearestInteger( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestInteger), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestInteger), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestInteger), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNearestInteger( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToNearestInteger(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNearestInteger(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNearestInteger(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNearestIntegerDouble(); var result = Sse41.RoundToNearestInteger(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNearestInteger(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNearestInteger(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs index 74bb1000b9..c6c1d7ae0c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestInteger.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNearestInteger( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNearestInteger( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNearestInteger( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestInteger), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestInteger), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestInteger), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNearestInteger( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToNearestInteger(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNearestInteger(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNearestInteger(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNearestIntegerSingle(); var result = Sse41.RoundToNearestInteger(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNearestInteger(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNearestInteger(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs index 2919bf2754..a1fdb69377 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNearestIntegerScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNearestIntegerScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNearestIntegerScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestIntegerScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestIntegerScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestIntegerScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNearestIntegerScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToNearestIntegerScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNearestIntegerScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNearestIntegerScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToNearestIntegerScalarDouble(); var result = Sse41.RoundToNearestIntegerScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNearestIntegerScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNearestIntegerScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs index 18a37bd1d3..6c4ebf6148 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNearestIntegerScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNearestIntegerScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNearestIntegerScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNearestIntegerScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestIntegerScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestIntegerScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNearestIntegerScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNearestIntegerScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToNearestIntegerScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNearestIntegerScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNearestIntegerScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToNearestIntegerScalarSingle(); var result = Sse41.RoundToNearestIntegerScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNearestIntegerScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNearestIntegerScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs index 547a894ee6..59e4f52647 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNegativeInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNegativeInfinity( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNegativeInfinity( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNegativeInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToNegativeInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNegativeInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNegativeInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNegativeInfinityDouble(); var result = Sse41.RoundToNegativeInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNegativeInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNegativeInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs index f8f2d94f2a..3916cd1a98 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinity.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNegativeInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNegativeInfinity( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNegativeInfinity( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNegativeInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToNegativeInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNegativeInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToNegativeInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToNegativeInfinitySingle(); var result = Sse41.RoundToNegativeInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNegativeInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNegativeInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs index 0b6d19baef..d0dcef221a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNegativeInfinityScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNegativeInfinityScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNegativeInfinityScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNegativeInfinityScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToNegativeInfinityScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNegativeInfinityScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNegativeInfinityScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToNegativeInfinityScalarDouble(); var result = Sse41.RoundToNegativeInfinityScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNegativeInfinityScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNegativeInfinityScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs index 62bab55e56..59a8751889 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToNegativeInfinityScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToNegativeInfinityScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToNegativeInfinityScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToNegativeInfinityScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToNegativeInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToNegativeInfinityScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToNegativeInfinityScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNegativeInfinityScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToNegativeInfinityScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToNegativeInfinityScalarSingle(); var result = Sse41.RoundToNegativeInfinityScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToNegativeInfinityScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToNegativeInfinityScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs index 8c56cf3c91..99da59e915 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToPositiveInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToPositiveInfinity( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToPositiveInfinity( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToPositiveInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToPositiveInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToPositiveInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToPositiveInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToPositiveInfinityDouble(); var result = Sse41.RoundToPositiveInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToPositiveInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToPositiveInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs index a66cc82fc1..558caf986b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinity.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToPositiveInfinity( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToPositiveInfinity( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToPositiveInfinity( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinity), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToPositiveInfinity( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToPositiveInfinity(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToPositiveInfinity(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToPositiveInfinity(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToPositiveInfinitySingle(); var result = Sse41.RoundToPositiveInfinity(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToPositiveInfinity(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToPositiveInfinity(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs index 793087e07f..af43996699 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToPositiveInfinityScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToPositiveInfinityScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToPositiveInfinityScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToPositiveInfinityScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToPositiveInfinityScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToPositiveInfinityScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToPositiveInfinityScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToPositiveInfinityScalarDouble(); var result = Sse41.RoundToPositiveInfinityScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToPositiveInfinityScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToPositiveInfinityScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs index 1345a8cc5d..7b733249e5 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToPositiveInfinityScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToPositiveInfinityScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToPositiveInfinityScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToPositiveInfinityScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToPositiveInfinityScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToPositiveInfinityScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToPositiveInfinityScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToPositiveInfinityScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToPositiveInfinityScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToPositiveInfinityScalarSingle(); var result = Sse41.RoundToPositiveInfinityScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToPositiveInfinityScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToPositiveInfinityScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs index f6da93be09..ee8959ec32 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Double.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToZero( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToZero( Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToZero( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZero), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZero), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZero), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToZero( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToZero(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToZero(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToZero(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToZeroDouble(); var result = Sse41.RoundToZero(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToZero(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToZero(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs index 8d0406a1cb..614e10e200 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZero.Single.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToZero( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToZero( Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToZero( Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZero), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZero), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZero), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToZero( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.RoundToZero(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse.LoadVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToZero(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse.LoadAlignedVector128((Single*)(_dataTable.inArrayPtr)); var result = Sse41.RoundToZero(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__RoundToZeroSingle(); var result = Sse41.RoundToZero(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToZero(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToZero(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs index 9a63a9ce26..a945959fe8 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Double.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToZeroScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToZeroScalar( Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToZeroScalar( Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZeroScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZeroScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZeroScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToZeroScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToZeroScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToZeroScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Double*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToZeroScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToZeroScalarDouble(); var result = Sse41.RoundToZeroScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToZeroScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToZeroScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs index 7dba17e346..5e0a0547ca 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/RoundToZeroScalar.Single.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.RoundToZeroScalar( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.RoundToZeroScalar( Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.RoundToZeroScalar( Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZeroScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZeroScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.RoundToZeroScalar), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.RoundToZeroScalar( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.RoundToZeroScalar(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse.LoadVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToZeroScalar(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray1Ptr)); var right = Sse.LoadAlignedVector128((Single*)(_dataTable.inArray2Ptr)); var result = Sse41.RoundToZeroScalar(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__RoundToZeroScalarSingle(); var result = Sse41.RoundToZeroScalar(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.RoundToZeroScalar(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.RoundToZeroScalar(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs index 2bee133ba0..4a7053ed1e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Byte.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesByte(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs index 1bcb4bdf0f..8eead89a6a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int16.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesInt16(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs index 52a5cecaeb..899dce665d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int32.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesInt32(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs index 843ba3fc48..8eb6f402a7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.Int64.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesInt64(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs index 81310f70c8..5284593734 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.SByte.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesSByte(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs index 1077755e71..951731a97b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt16.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesUInt16(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs index 8084c2a21e..4fede7461b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt32.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesUInt32(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs index bac74acc06..870b895218 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllOnes.UInt64.cs @@ -148,6 +148,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllOnes( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -157,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllOnes( Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -166,6 +170,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllOnes( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)) ); @@ -175,6 +181,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -185,6 +193,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)) @@ -195,6 +205,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse41).GetMethod(nameof(Sse41.TestAllOnes), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)) @@ -205,6 +217,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllOnes( _clsVar ); @@ -214,6 +228,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var value = Unsafe.Read>(_dataTable.inArrayPtr); var result = Sse41.TestAllOnes(value); @@ -222,6 +238,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var value = Sse2.LoadVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -230,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var value = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArrayPtr)); var result = Sse41.TestAllOnes(value); @@ -238,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanUnaryOpTest__TestAllOnesUInt64(); var result = Sse41.TestAllOnes(test._fld); @@ -246,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllOnes(_fld); ValidateResult(_fld, result); @@ -253,6 +277,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllOnes(test._fld); ValidateResult(test._fld, result); @@ -260,12 +286,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs index a49c859e50..196a4a8ca3 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosByte(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs index 7bb419b025..c7f76179f6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosInt16(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs index 1c5b4bf92b..6368e04103 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosInt32(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs index e230e15320..f273f0f4b2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosInt64(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs index a02fdc80b7..ea40e9fa10 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosSByte(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs index b26926c630..3fae2c60de 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosUInt16(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs index 7be1f21076..c4a3d98746 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosUInt32(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs index 78dcda0d65..ba7d9db36b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestAllZeros.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestAllZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestAllZeros( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestAllZeros( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestAllZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestAllZeros( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestAllZeros(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestAllZeros(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestAllZerosUInt64(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestAllZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestAllZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs index 3aeec539a0..682a4dcebf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCByte(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs index 63617ecc11..7b9ca585c7 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCInt16(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs index ffce931d85..5bba8ed2c6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCInt32(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs index bf694e1fca..23454d957e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCInt64(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs index 8d11601a29..37ae5986ee 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCSByte(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs index 769e1e66cd..c510fb2397 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCUInt16(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs index 483da21548..b02ee85420 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCUInt32(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs index c2ab04cc5f..d9307526b4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestC.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestC( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestC( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestC( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestC(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestC(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestCUInt64(); var result = Sse41.TestC(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs index 732206781b..e6a5ef9de4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosByte(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs index 3128a26775..e570fe8fd0 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosInt16(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs index c126f8e93f..7c31a5ac09 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosInt32(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs index ee64927b2f..bc8f56f748 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosInt64(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs index 00f98fa364..e18bd2c5d2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosSByte(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs index 27fdc3596f..283ee9f60f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosUInt16(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs index d18b495d25..5987502b12 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosUInt32(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs index 57c01315db..fe504ad75c 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestMixOnesZeros.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestMixOnesZeros( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestMixOnesZeros( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestMixOnesZeros( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestMixOnesZeros(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestMixOnesZeros(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestMixOnesZerosUInt64(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestMixOnesZeros(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestMixOnesZeros(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs index 9aaad1387f..b447b297a4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCByte(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs index 555d29c89c..2e54f91262 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCInt16(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs index 41c0143201..d518e32875 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCInt32(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs index 30bc7be9f7..ea893f91ff 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCInt64(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs index 37826a71c3..0a4f3b6a0f 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCSByte(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs index 6bb8db66f5..437609ee1e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCUInt16(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs index 901440e265..6c2e65b0f6 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCUInt32(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs index 6e3dc3c900..95e9ea0bbb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestNotZAndNotC.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestNotZAndNotC( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestNotZAndNotC( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -218,7 +228,10 @@ namespace JIT.HardwareIntrinsics.X86 } public void RunReflectionScenario_LoadAligned() - {var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); + { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) { @@ -233,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestNotZAndNotC( _clsVar1, _clsVar2 @@ -243,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestNotZAndNotC(left, right); @@ -252,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -261,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestNotZAndNotC(left, right); @@ -270,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanTwoComparisonOpTest__TestNotZAndNotCUInt64(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); @@ -278,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestNotZAndNotC(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -285,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestNotZAndNotC(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -292,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs index e9f214b461..1fae6ed24e 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Byte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZByte(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs index 69f2f4ca1c..5949a02e2b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZInt16(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs index e53b85c743..bee3666f50 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZInt32(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs index 6a2bed5402..e1a2eebc8d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.Int64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZInt64(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs index bec8c5a968..407acf1045 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.SByte.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZSByte(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs index 88e8a53163..53f678f75a 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt16.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt16*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 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 = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZUInt16(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs index 1b314317a4..19b4147f45 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt32.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt32*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZUInt32(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs index 1ac6de13e0..5b61f56332 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse41/TestZ.UInt64.cs @@ -159,6 +159,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse41.TestZ( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -169,6 +171,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse41.TestZ( Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -179,6 +183,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse41.TestZ( Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)) @@ -189,6 +195,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -204,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var method = typeof(Sse41).GetMethod(nameof(Sse41.TestZ), new Type[] { typeof(Vector128), typeof(Vector128) }); if (method != null) @@ -234,6 +246,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse41.TestZ( _clsVar1, _clsVar2 @@ -244,6 +258,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse41.TestZ(left, right); @@ -253,6 +269,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((UInt64*)(_dataTable.inArray2Ptr)); var result = Sse41.TestZ(left, right); @@ -271,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new BooleanBinaryOpTest__TestZUInt64(); var result = Sse41.TestZ(test._fld1, test._fld2); @@ -279,6 +301,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse41.TestZ(_fld1, _fld2); ValidateResult(_fld1, _fld2, result); @@ -286,6 +310,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse41.TestZ(test._fld1, test._fld2); ValidateResult(test._fld1, test._fld2, result); @@ -293,12 +319,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs b/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs index fea15cc3d7..f3463bc3bf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Sse42/CompareGreaterThan.Int64.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Sse42.CompareGreaterThan( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Sse42.CompareGreaterThan( Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Sse42.CompareGreaterThan( Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Sse42).GetMethod(nameof(Sse42.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Sse42).GetMethod(nameof(Sse42.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Sse42).GetMethod(nameof(Sse42.CompareGreaterThan), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Sse42.CompareGreaterThan( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Sse42.CompareGreaterThan(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse42.CompareGreaterThan(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int64*)(_dataTable.inArray2Ptr)); var result = Sse42.CompareGreaterThan(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__CompareGreaterThanInt64(); var result = Sse42.CompareGreaterThan(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Sse42.CompareGreaterThan(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Sse42.CompareGreaterThan(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs index 52b20b3dac..b90cab02ac 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.Byte.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Abs( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Abs( Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Abs( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Abs( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Ssse3.Abs(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((SByte*)(_dataTable.inArrayPtr)); var result = Ssse3.Abs(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArrayPtr)); var result = Ssse3.Abs(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__AbsByte(); var result = Ssse3.Abs(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Abs(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Abs(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs index 7354010d3c..cd6c4371f9 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt16.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Abs( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Abs( Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Abs( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Abs( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Ssse3.Abs(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int16*)(_dataTable.inArrayPtr)); var result = Ssse3.Abs(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArrayPtr)); var result = Ssse3.Abs(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__AbsUInt16(); var result = Ssse3.Abs(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Abs(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Abs(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs index 2d88451f15..3d692e376b 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Abs.UInt32.cs @@ -150,6 +150,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Abs( Unsafe.Read>(_dataTable.inArrayPtr) ); @@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Abs( Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -170,6 +174,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Abs( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)) ); @@ -180,6 +186,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArrayPtr) @@ -191,6 +199,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)) @@ -202,6 +212,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Abs), new Type[] { typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)) @@ -213,6 +225,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Abs( _clsVar ); @@ -223,6 +237,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var firstOp = Unsafe.Read>(_dataTable.inArrayPtr); var result = Ssse3.Abs(firstOp); @@ -232,6 +248,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var firstOp = Sse2.LoadVector128((Int32*)(_dataTable.inArrayPtr)); var result = Ssse3.Abs(firstOp); @@ -241,6 +259,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var firstOp = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArrayPtr)); var result = Ssse3.Abs(firstOp); @@ -250,6 +270,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleUnaryOpTest__AbsUInt32(); var result = Ssse3.Abs(test._fld); @@ -259,6 +281,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Abs(_fld); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -267,6 +291,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Abs(test._fld); @@ -276,12 +302,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs index a728599843..f8fd6b8e97 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.HorizontalAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.HorizontalAdd( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.HorizontalAdd( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.HorizontalAdd( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.HorizontalAdd(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalAdd(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalAdd(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalAddInt16(); var result = Ssse3.HorizontalAdd(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.HorizontalAdd(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.HorizontalAdd(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs index 893dbd87ac..0e3e3b6724 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAdd.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.HorizontalAdd( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.HorizontalAdd( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.HorizontalAdd( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAdd), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.HorizontalAdd( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.HorizontalAdd(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalAdd(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalAdd(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalAddInt32(); var result = Ssse3.HorizontalAdd(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.HorizontalAdd(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.HorizontalAdd(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs index f3d1b9be32..6727350d7d 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalAddSaturate.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.HorizontalAddSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.HorizontalAddSaturate( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.HorizontalAddSaturate( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalAddSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.HorizontalAddSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.HorizontalAddSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalAddSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalAddSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalAddSaturateInt16(); var result = Ssse3.HorizontalAddSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.HorizontalAddSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.HorizontalAddSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs index 60fbc634c7..bb8b911c59 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.HorizontalSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.HorizontalSubtract( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.HorizontalSubtract( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.HorizontalSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.HorizontalSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalSubtractInt16(); var result = Ssse3.HorizontalSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.HorizontalSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.HorizontalSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs index e5748c39da..7531d80ee4 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtract.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.HorizontalSubtract( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.HorizontalSubtract( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.HorizontalSubtract( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtract), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.HorizontalSubtract( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.HorizontalSubtract(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalSubtract(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalSubtract(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalSubtractInt32(); var result = Ssse3.HorizontalSubtract(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.HorizontalSubtract(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.HorizontalSubtract(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs index 411d89cbb2..2cd863d099 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/HorizontalSubtractSaturate.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.HorizontalSubtractSaturate( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.HorizontalSubtractSaturate( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.HorizontalSubtractSaturate( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.HorizontalSubtractSaturate), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.HorizontalSubtractSaturate( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.HorizontalSubtractSaturate(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalSubtractSaturate(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.HorizontalSubtractSaturate(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new HorizontalBinaryOpTest__HorizontalSubtractSaturateInt16(); var result = Ssse3.HorizontalSubtractSaturate(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.HorizontalSubtractSaturate(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.HorizontalSubtractSaturate(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs index 4d669a0263..dbaba18786 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyAddAdjacent.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.MultiplyAddAdjacent( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.MultiplyAddAdjacent( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.MultiplyAddAdjacent( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.MultiplyAddAdjacent), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.MultiplyAddAdjacent), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.MultiplyAddAdjacent), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.MultiplyAddAdjacent( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.MultiplyAddAdjacent(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Ssse3.MultiplyAddAdjacent(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Ssse3.MultiplyAddAdjacent(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplyAddAdjacentInt16(); var result = Ssse3.MultiplyAddAdjacent(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.MultiplyAddAdjacent(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.MultiplyAddAdjacent(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs index 4a4c3177c1..d9d5c50fdf 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/MultiplyHighRoundScale.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.MultiplyHighRoundScale( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.MultiplyHighRoundScale( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.MultiplyHighRoundScale( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.MultiplyHighRoundScale), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.MultiplyHighRoundScale), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.MultiplyHighRoundScale), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.MultiplyHighRoundScale( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.MultiplyHighRoundScale(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.MultiplyHighRoundScale(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.MultiplyHighRoundScale(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__MultiplyHighRoundScaleInt16(); var result = Ssse3.MultiplyHighRoundScale(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.MultiplyHighRoundScale(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.MultiplyHighRoundScale(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs index 71b80b36fb..389ff16aac 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.Byte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Shuffle( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Shuffle( Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Shuffle( Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Shuffle), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Shuffle), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Shuffle), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Shuffle( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.Shuffle(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Ssse3.Shuffle(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Byte*)(_dataTable.inArray2Ptr)); var result = Ssse3.Shuffle(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__ShuffleByte(); var result = Ssse3.Shuffle(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Shuffle(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Shuffle(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs index 87885b7512..44294761ef 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Shuffle.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Shuffle( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Shuffle( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Shuffle( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Shuffle), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Shuffle), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Shuffle), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Shuffle( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.Shuffle(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Ssse3.Shuffle(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Ssse3.Shuffle(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__ShuffleSByte(); var result = Ssse3.Shuffle(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Shuffle(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Shuffle(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs index da26dbfbc3..95adccd9eb 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int16.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Sign( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Sign( Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Sign( Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Sign( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.Sign(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.Sign(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int16*)(_dataTable.inArray2Ptr)); var result = Ssse3.Sign(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SignInt16(); var result = Ssse3.Sign(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Sign(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Sign(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs index adf643ce8e..c702a093b2 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.Int32.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Sign( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Sign( Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Sign( Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Sign( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.Sign(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Ssse3.Sign(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((Int32*)(_dataTable.inArray2Ptr)); var result = Ssse3.Sign(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SignInt32(); var result = Ssse3.Sign(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Sign(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Sign(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try diff --git a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs index c5f1fe6e83..d8b8313249 100644 --- a/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs +++ b/tests/src/JIT/HardwareIntrinsics/X86/Ssse3/Sign.SByte.cs @@ -162,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead)); + var result = Ssse3.Sign( Unsafe.Read>(_dataTable.inArray1Ptr), Unsafe.Read>(_dataTable.inArray2Ptr) @@ -173,6 +175,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load)); + var result = Ssse3.Sign( Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -184,6 +188,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunBasicScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned)); + var result = Ssse3.Sign( Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)) @@ -195,6 +201,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_UnsafeRead)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Unsafe.Read>(_dataTable.inArray1Ptr), @@ -207,6 +215,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -219,6 +229,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunReflectionScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned)); + var result = typeof(Ssse3).GetMethod(nameof(Ssse3.Sign), new Type[] { typeof(Vector128), typeof(Vector128) }) .Invoke(null, new object[] { Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)), @@ -231,6 +243,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClsVarScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario)); + var result = Ssse3.Sign( _clsVar1, _clsVar2 @@ -242,6 +256,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_UnsafeRead() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead)); + var left = Unsafe.Read>(_dataTable.inArray1Ptr); var right = Unsafe.Read>(_dataTable.inArray2Ptr); var result = Ssse3.Sign(left, right); @@ -252,6 +268,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_Load() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load)); + var left = Sse2.LoadVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Ssse3.Sign(left, right); @@ -262,6 +280,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunLclVarScenario_LoadAligned() { + TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned)); + var left = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray1Ptr)); var right = Sse2.LoadAlignedVector128((SByte*)(_dataTable.inArray2Ptr)); var result = Ssse3.Sign(left, right); @@ -272,6 +292,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario)); + var test = new SimpleBinaryOpTest__SignSByte(); var result = Ssse3.Sign(test._fld1, test._fld2); @@ -281,6 +303,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunClassFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario)); + var result = Ssse3.Sign(_fld1, _fld2); Unsafe.Write(_dataTable.outArrayPtr, result); @@ -289,6 +313,8 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructLclFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario)); + var test = TestStruct.Create(); var result = Ssse3.Sign(test._fld1, test._fld2); @@ -298,12 +324,16 @@ namespace JIT.HardwareIntrinsics.X86 public void RunStructFldScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunStructFldScenario)); + var test = TestStruct.Create(); test.RunStructFldScenario(this); } public void RunUnsupportedScenario() { + TestLibrary.TestFramework.BeginScenario(nameof(RunUnsupportedScenario)); + Succeeded = false; try -- cgit v1.2.3