Regenerating the templated x86 HWIntrinsic tests.

772 files changed, 22932 insertions, 24 deletions

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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Byte>(
                 Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<Byte>(
                 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<Byte>(
                 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<Byte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<Byte>(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<Byte>(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<Byte>(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<Byte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<Byte>(_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<Double>(
                 Unsafe.Read<Vector128<Double>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<Double>(
                 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<Double>(
                 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<Double>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<Double>(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<Double>(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<Double>(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<Double>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<Double>(_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<Int16>(
                 Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<Int16>(
                 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<Int16>(
                 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<Int16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<Int16>(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<Int16>(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<Int16>(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<Int16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<Int16>(_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<Int32>(
                 Unsafe.Read<Vector128<Int32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<Int32>(
                 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<Int32>(
                 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<Int32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int32>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<Int32>(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<Int32>(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<Int32>(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<Int32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<Int32>(_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<Int64>(
                 Unsafe.Read<Vector128<Int64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<Int64>(
                 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<Int64>(
                 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<Int64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int64>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<Int64>(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<Int64>(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<Int64>(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<Int64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<Int64>(_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<SByte>(
                 Unsafe.Read<Vector128<SByte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<SByte>(
                 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<SByte>(
                 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<SByte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<SByte>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<SByte>(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<SByte>(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<SByte>(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<SByte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<SByte>(_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<Single>(
                 Unsafe.Read<Vector128<Single>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<Single>(
                 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<Single>(
                 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<Single>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<Single>(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<Single>(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<Single>(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<Single>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<Single>(_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<UInt16>(
                 Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<UInt16>(
                 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<UInt16>(
                 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<UInt16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<UInt16>(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<UInt16>(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<UInt16>(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<UInt16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<UInt16>(_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<UInt32>(
                 Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<UInt32>(
                 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<UInt32>(
                 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<UInt32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<UInt32>(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<UInt32>(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<UInt32>(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<UInt32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<UInt32>(_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<UInt64>(
                 Unsafe.Read<Vector128<UInt64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.ExtendToVector256<UInt64>(
                 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<UInt64>(
                 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<UInt64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArrayPtr);
             var result = Avx.ExtendToVector256<UInt64>(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<UInt64>(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<UInt64>(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<UInt64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.ExtendToVector256<UInt64>(_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<Vector256<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Double>>(_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<Double>), 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<Double>), 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<Double>), 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<Vector256<Double>>(_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<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<Single>>(_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<Single>), 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<Single>), 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<Single>), 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<Vector256<Single>>(_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<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Byte>(
                 Unsafe.Read<Vector256<Byte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<Byte>(
                 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<Byte>(
                 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<Byte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<Byte>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<Byte>(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<Byte>(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<Byte>(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<Byte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<Byte>(_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<Double>(
                 Unsafe.Read<Vector256<Double>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<Double>(
                 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<Double>(
                 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<Double>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<Double>(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<Double>(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<Double>(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<Double>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<Double>(_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<Int16>(
                 Unsafe.Read<Vector256<Int16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<Int16>(
                 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<Int16>(
                 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<Int16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<Int16>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<Int16>(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<Int16>(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<Int16>(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<Int16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<Int16>(_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<Int32>(
                 Unsafe.Read<Vector256<Int32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<Int32>(
                 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<Int32>(
                 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<Int32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<Int32>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<Int32>(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<Int32>(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<Int32>(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<Int32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<Int32>(_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<Int64>(
                 Unsafe.Read<Vector256<Int64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<Int64>(
                 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<Int64>(
                 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<Int64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<Int64>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<Int64>(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<Int64>(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<Int64>(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<Int64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<Int64>(_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<SByte>(
                 Unsafe.Read<Vector256<SByte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<SByte>(
                 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<SByte>(
                 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<SByte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<SByte>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<SByte>(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<SByte>(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<SByte>(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<SByte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<SByte>(_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<Single>(
                 Unsafe.Read<Vector256<Single>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<Single>(
                 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<Single>(
                 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<Single>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<Single>(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<Single>(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<Single>(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<Single>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<Single>(_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<UInt16>(
                 Unsafe.Read<Vector256<UInt16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<UInt16>(
                 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<UInt16>(
                 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<UInt16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<UInt16>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<UInt16>(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<UInt16>(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<UInt16>(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<UInt16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<UInt16>(_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<UInt32>(
                 Unsafe.Read<Vector256<UInt32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<UInt32>(
                 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<UInt32>(
                 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<UInt32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<UInt32>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<UInt32>(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<UInt32>(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<UInt32>(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<UInt32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<UInt32>(_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<UInt64>(
                 Unsafe.Read<Vector256<UInt64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx.GetLowerHalf<UInt64>(
                 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<UInt64>(
                 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<UInt64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector256<UInt64>>(_dataTable.inArrayPtr);
             var result = Avx.GetLowerHalf<UInt64>(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<UInt64>(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<UInt64>(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<UInt64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx.GetLowerHalf<UInt64>(_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<Vector256<Byte>>(_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<Byte>), typeof(Byte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Byte>>(_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<Byte>), typeof(Byte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Byte>>(_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<Byte>), typeof(Byte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Int16>>(_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<Int16>), typeof(Int16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int16>>(_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<Int16>), typeof(Int16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int16>>(_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<Int16>), typeof(Int16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), typeof(Int32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(Int32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(Int32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), typeof(Int64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_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<Int64>), typeof(Int64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_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<Int64>), typeof(Int64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<SByte>>(_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<SByte>), typeof(SByte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<SByte>>(_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<SByte>), typeof(SByte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<SByte>>(_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<SByte>), typeof(SByte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(UInt16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(UInt16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(UInt16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(UInt32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(UInt32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(UInt32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(UInt64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(UInt64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(UInt64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Byte>>(_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<Byte>), typeof(Byte*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Double>>(_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<Double>), typeof(Double*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), 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<Double>), 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<Vector256<Double>>(_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<Vector256<Int16>>(_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<Int16>), typeof(Int16*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), typeof(Int32*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), typeof(Int64*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<SByte>>(_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<SByte>), typeof(SByte*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<Single>>(_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<Single>), typeof(Single*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), 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<Single>), 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<Vector256<Single>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(UInt16*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(UInt32*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(UInt64*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), 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<Double>), 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<Vector256<Double>>(_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<Vector128<Double>>(_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<Double>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), 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<Double>), 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<Vector128<Double>>(_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<Vector256<Single>>(_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<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), 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<Single>), 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<Vector256<Single>>(_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<Vector128<Single>>(_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<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), 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<Single>), 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<Vector128<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), 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<Double>), typeof(Vector256<Double>), 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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), 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<Single>), typeof(Vector256<Single>), 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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) });
 
             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<Byte>), typeof(Vector256<Byte>) });
 
             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<Byte>), typeof(Vector256<Byte>) });
 
             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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) });
 
             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<Int16>), typeof(Vector256<Int16>) });
 
             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<Int16>), typeof(Vector256<Int16>) });
 
             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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) });
 
             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<Int32>), typeof(Vector256<Int32>) });
 
             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<Int32>), typeof(Vector256<Int32>) });
 
             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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) });
 
             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<Int64>), typeof(Vector256<Int64>) });
 
             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<Int64>), typeof(Vector256<Int64>) });
 
             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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) });
 
             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<SByte>), typeof(Vector256<SByte>) });
 
             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<SByte>), typeof(Vector256<SByte>) });
 
             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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) });
 
             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<Byte>), typeof(Vector256<Byte>) });
 
             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<Byte>), typeof(Vector256<Byte>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<Byte>), typeof(Vector256<Byte>) });
 
             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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) });
 
             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<Int16>), typeof(Vector256<Int16>) });
 
             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<Int16>), typeof(Vector256<Int16>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<Int16>), typeof(Vector256<Int16>) });
 
             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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) });
 
             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<Int32>), typeof(Vector256<Int32>) });
 
             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<Int32>), typeof(Vector256<Int32>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<Int32>), typeof(Vector256<Int32>) });
 
             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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) });
 
             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<Int64>), typeof(Vector256<Int64>) });
 
             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<Int64>), typeof(Vector256<Int64>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<Int64>), typeof(Vector256<Int64>) });
 
             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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) });
 
             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<SByte>), typeof(Vector256<SByte>) });
 
             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<SByte>), typeof(Vector256<SByte>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<SByte>), typeof(Vector256<SByte>) });
 
             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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<UInt16>), typeof(Vector256<UInt16>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<UInt16>), typeof(Vector256<UInt16>) });
 
             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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<UInt32>), typeof(Vector256<UInt32>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<UInt32>), typeof(Vector256<UInt32>) });
 
             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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<UInt64>), typeof(Vector256<UInt64>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256<UInt64>), typeof(Vector256<UInt64>) });
 
             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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) });
 
             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<Byte>), typeof(Vector256<Byte>) });
 
             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<Byte>), typeof(Vector256<Byte>) });
 
             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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) });
 
             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<Int16>), typeof(Vector256<Int16>) });
 
             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<Int16>), typeof(Vector256<Int16>) });
 
             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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) });
 
             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<Int32>), typeof(Vector256<Int32>) });
 
             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<Int32>), typeof(Vector256<Int32>) });
 
             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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) });
 
             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<Int64>), typeof(Vector256<Int64>) });
 
             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<Int64>), typeof(Vector256<Int64>) });
 
             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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) });
 
             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<SByte>), typeof(Vector256<SByte>) });
 
             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<SByte>), typeof(Vector256<SByte>) });
 
             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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<UInt16>), typeof(Vector256<UInt16>) });
 
             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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<UInt32>), typeof(Vector256<UInt32>) });
 
             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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<UInt64>), typeof(Vector256<UInt64>) });
 
             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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Single>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), 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<SByte>), typeof(Vector256<SByte>), 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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), 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<SByte>), typeof(Vector256<SByte>), 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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), 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<SByte>), typeof(Vector256<SByte>), 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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), 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<SByte>), typeof(Vector256<SByte>), 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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), 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<Int16>), typeof(Vector256<Int16>), 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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), 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<Int16>), typeof(Vector256<Int16>), 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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), 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<Int16>), typeof(Vector256<Int16>), 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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>), 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<Int16>), typeof(Vector256<Int16>), 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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), 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<Int32>), typeof(Vector256<Int32>), 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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), 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<Int32>), typeof(Vector256<Int32>), 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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), 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<Int32>), typeof(Vector256<Int32>), 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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), 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<Int32>), typeof(Vector256<Int32>), 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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), 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<UInt16>), typeof(Vector256<UInt16>), 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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), 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<UInt16>), typeof(Vector256<UInt16>), 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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), 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<UInt16>), typeof(Vector256<UInt16>), 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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>), 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<UInt16>), typeof(Vector256<UInt16>), 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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), 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<UInt32>), typeof(Vector256<UInt32>), 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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), 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<UInt32>), typeof(Vector256<UInt32>), 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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), 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<UInt32>), typeof(Vector256<UInt32>), 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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), 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<UInt32>), typeof(Vector256<UInt32>), 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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Byte>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Byte>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<SByte>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<SByte>>(_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<Byte>(
                 Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<Byte>(
                 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<Byte>(
                 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<Byte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<Byte>(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<Byte>(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<Byte>(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<Byte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<Byte>(_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<Double>(
                 Unsafe.Read<Vector128<Double>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<Double>(
                 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<Double>(
                 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<Double>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<Double>(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<Double>(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<Double>(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<Double>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<Double>(_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<Int16>(
                 Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<Int16>(
                 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<Int16>(
                 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<Int16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<Int16>(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<Int16>(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<Int16>(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<Int16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<Int16>(_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<Int32>(
                 Unsafe.Read<Vector128<Int32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<Int32>(
                 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<Int32>(
                 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<Int32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int32>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<Int32>(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<Int32>(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<Int32>(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<Int32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<Int32>(_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<Int64>(
                 Unsafe.Read<Vector128<Int64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<Int64>(
                 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<Int64>(
                 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<Int64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int64>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<Int64>(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<Int64>(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<Int64>(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<Int64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<Int64>(_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<SByte>(
                 Unsafe.Read<Vector128<SByte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<SByte>(
                 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<SByte>(
                 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<SByte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<SByte>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<SByte>(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<SByte>(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<SByte>(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<SByte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<SByte>(_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<Single>(
                 Unsafe.Read<Vector128<Single>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<Single>(
                 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<Single>(
                 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<Single>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<Single>(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<Single>(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<Single>(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<Single>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<Single>(_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<UInt16>(
                 Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<UInt16>(
                 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<UInt16>(
                 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<UInt16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<UInt16>(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<UInt16>(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<UInt16>(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<UInt16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<UInt16>(_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<UInt32>(
                 Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<UInt32>(
                 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<UInt32>(
                 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<UInt32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<UInt32>(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<UInt32>(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<UInt32>(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<UInt32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<UInt32>(_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<UInt64>(
                 Unsafe.Read<Vector128<UInt64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector128<UInt64>(
                 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<UInt64>(
                 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<UInt64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector128<UInt64>(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<UInt64>(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<UInt64>(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<UInt64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector128<UInt64>(_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<Byte>(
                 Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<Byte>(
                 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<Byte>(
                 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<Byte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Byte>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<Byte>(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<Byte>(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<Byte>(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<Byte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<Byte>(_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<Double>(
                 Unsafe.Read<Vector128<Double>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<Double>(
                 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<Double>(
                 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<Double>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<Double>(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<Double>(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<Double>(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<Double>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<Double>(_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<Int16>(
                 Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<Int16>(
                 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<Int16>(
                 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<Int16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int16>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<Int16>(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<Int16>(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<Int16>(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<Int16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<Int16>(_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<Int32>(
                 Unsafe.Read<Vector128<Int32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<Int32>(
                 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<Int32>(
                 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<Int32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int32>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<Int32>(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<Int32>(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<Int32>(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<Int32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<Int32>(_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<Int64>(
                 Unsafe.Read<Vector128<Int64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<Int64>(
                 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<Int64>(
                 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<Int64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Int64>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<Int64>(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<Int64>(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<Int64>(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<Int64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<Int64>(_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<SByte>(
                 Unsafe.Read<Vector128<SByte>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<SByte>(
                 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<SByte>(
                 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<SByte>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<SByte>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<SByte>(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<SByte>(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<SByte>(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<SByte>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<SByte>(_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<Single>(
                 Unsafe.Read<Vector128<Single>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<Single>(
                 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<Single>(
                 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<Single>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<Single>(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<Single>(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<Single>(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<Single>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<Single>(_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<UInt16>(
                 Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<UInt16>(
                 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<UInt16>(
                 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<UInt16>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt16>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<UInt16>(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<UInt16>(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<UInt16>(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<UInt16>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<UInt16>(_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<UInt32>(
                 Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<UInt32>(
                 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<UInt32>(
                 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<UInt32>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt32>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<UInt32>(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<UInt32>(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<UInt32>(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<UInt32>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<UInt32>(_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<UInt64>(
                 Unsafe.Read<Vector128<UInt64>>(_dataTable.inArrayPtr)
             );
@@ -160,6 +162,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunBasicScenario_Load()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
+
             var result = Avx2.BroadcastScalarToVector256<UInt64>(
                 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<UInt64>(
                 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<UInt64>(
                 _clsVar
             );
@@ -226,6 +240,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var firstOp = Unsafe.Read<Vector128<UInt64>>(_dataTable.inArrayPtr);
             var result = Avx2.BroadcastScalarToVector256<UInt64>(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<UInt64>(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<UInt64>(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<UInt64>(test._fld);
 
@@ -262,6 +284,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunClassFldScenario()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
+
             var result = Avx2.BroadcastScalarToVector256<UInt64>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector256<Double>>(_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<Vector256<Int32>>(_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<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>) })
                                      .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<Int32>) })
                                      .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<Vector256<Int32>>(_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<Vector256<UInt32>>(_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<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>) })
                                      .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<UInt32>) })
                                      .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<Vector256<UInt32>>(_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<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<SByte>>(_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<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Byte>>(_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<Byte>), typeof(Byte*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<Byte>), typeof(Vector128<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector128<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<Byte>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<Int16>>(_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<Int16>), typeof(Int16*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<Int16>), typeof(Vector128<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector128<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<Int16>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<Int32>>(_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<Int32>), typeof(Int32*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<Int32>), typeof(Vector128<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector128<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<Int32>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<Int64>>(_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<Int64>), typeof(Int64*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<Int64>), typeof(Vector128<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector128<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<Int64>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<SByte>>(_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<SByte>), typeof(SByte*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<SByte>), typeof(Vector128<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector128<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<SByte>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<UInt16>>(_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<UInt16>), typeof(UInt16*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<UInt16>), typeof(Vector128<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector128<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<UInt16>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<UInt32>>(_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<UInt32>), typeof(UInt32*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector128<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<UInt32>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<UInt64>>(_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<UInt64>), typeof(UInt64*), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<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)),
                 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<UInt64>), typeof(Vector128<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector128<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<UInt64>), typeof(Vector128<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,
                 _clsVar2,
@@ -251,6 +265,8 @@ namespace JIT.HardwareIntrinsics.X86
 
         public void RunLclVarScenario_UnsafeRead()
         {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
+
             var left = Unsafe.Read<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<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 = 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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>), 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<Int32>), typeof(Vector256<Int32>), 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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>), 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<Int64>), typeof(Vector256<Int64>), 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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>), 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<UInt32>), typeof(Vector256<UInt32>), 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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>), 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<UInt64>), typeof(Vector256<UInt64>), 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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<SByte>>(_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<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), 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<Byte>), 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<Vector256<Byte>>(_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<Vector256<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), 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<Int16>), 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<Vector256<Int16>>(_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<Vector256<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), 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<Int32>), 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<Vector256<Int32>>(_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<Vector256<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), 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<Int64>), 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<Vector256<Int64>>(_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<Vector256<SByte>>(_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<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), 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<SByte>), 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<Vector256<SByte>>(_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<Vector256<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector256<UInt16>>(_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<Vector256<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector256<UInt32>>(_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<Vector256<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector256<UInt64>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector256<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Byte>>(_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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Byte>), typeof(Vector256<Byte>) })
                                      .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<Vector256<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Byte>>(_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<Vector256<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int16>>(_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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Int16>), typeof(Vector256<Int16>) })
                                      .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<Vector256<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int16>>(_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<Vector256<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int32>>(_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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Int32>), typeof(Vector256<Int32>) })
                                      .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<Vector256<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int32>>(_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<Vector256<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Int64>>(_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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Int64>), typeof(Vector256<Int64>) })
                                      .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<Vector256<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<Int64>>(_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<Vector256<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<SByte>>(_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<SByte>), typeof(Vector256<SByte>) })
                                      .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<SByte>), typeof(Vector256<SByte>) })
                                      .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<Vector256<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<SByte>>(_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<Vector256<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt16>>(_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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<UInt16>), typeof(Vector256<UInt16>) })
                                      .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<Vector256<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt16>>(_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<Vector256<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt32>>(_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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<UInt32>), typeof(Vector256<UInt32>) })
                                      .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<Vector256<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt32>>(_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<Vector256<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<UInt64>>(_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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<UInt64>), typeof(Vector256<UInt64>) })
                                      .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<Vector256<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector256<UInt64>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), 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<Int32>), typeof(Vector128<Int32>), 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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), 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<Int32>), typeof(Vector128<Int32>), 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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), 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<Int32>), typeof(Vector128<Int32>), 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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>), 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<Int32>), typeof(Vector128<Int32>), 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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), 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<UInt32>), typeof(Vector128<UInt32>), 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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), 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<UInt32>), typeof(Vector128<UInt32>), 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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), 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<UInt32>), typeof(Vector128<UInt32>), 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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>), 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<UInt32>), typeof(Vector128<UInt32>), 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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<UInt32>(ref Unsafe.As<UInt32, byte>(ref _data1)),
                 Unsafe.ReadUnaligned<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(ref _data1));
             var data2 = Unsafe.ReadUnaligned<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(ref _data1)),
                 Unsafe.ReadUnaligned<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(ref _data1));
             var data2 = Unsafe.ReadUnaligned<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(ref _data1)),
                 Unsafe.ReadUnaligned<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(ref _data1));
             var data2 = Unsafe.ReadUnaligned<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(ref _data1)),
                 Unsafe.ReadUnaligned<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(ref _data1));
             var data2 = Unsafe.ReadUnaligned<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(ref _data1)),
                 Unsafe.ReadUnaligned<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(ref _data1));
             var data2 = Unsafe.ReadUnaligned<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(ref _data1)),
                 Unsafe.ReadUnaligned<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(ref _data1));
             var data2 = Unsafe.ReadUnaligned<UInt64>(ref Unsafe.As<UInt64, byte>(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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Single>>(_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<Vector256<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Double>>(_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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Double>), typeof(Vector256<Double>), typeof(Vector256<Double>) })
                                      .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<Vector256<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Double>>(_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<Vector256<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector256<Single>>(_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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Single>), typeof(Vector256<Single>), typeof(Vector256<Single>) })
                                      .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<Vector256<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector256<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector256<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<Int16>>(_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<Int16>), typeof(Int16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int16>>(_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<Int16>), typeof(Int16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(UInt16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(UInt16), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Byte>(ref Unsafe.As<Byte, byte>(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<Byte>(ref Unsafe.As<Byte, byte>(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<Byte>(ref Unsafe.As<Byte, byte>(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<Double>(ref Unsafe.As<Double, byte>(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<Double>(ref Unsafe.As<Double, byte>(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<Double>(ref Unsafe.As<Double, byte>(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<Int16>(ref Unsafe.As<Int16, byte>(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<Int16>(ref Unsafe.As<Int16, byte>(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<Int16>(ref Unsafe.As<Int16, byte>(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<Int32>(ref Unsafe.As<Int32, byte>(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<Int32>(ref Unsafe.As<Int32, byte>(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<Int32>(ref Unsafe.As<Int32, byte>(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<Int64>(ref Unsafe.As<Int64, byte>(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<Int64>(ref Unsafe.As<Int64, byte>(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<Int64>(ref Unsafe.As<Int64, byte>(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<SByte>(ref Unsafe.As<SByte, byte>(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<SByte>(ref Unsafe.As<SByte, byte>(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<SByte>(ref Unsafe.As<SByte, byte>(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<UInt16>(ref Unsafe.As<UInt16, byte>(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<UInt16>(ref Unsafe.As<UInt16, byte>(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<UInt16>(ref Unsafe.As<UInt16, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt32>(ref Unsafe.As<UInt32, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<UInt64>(ref Unsafe.As<UInt64, byte>(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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), 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<Byte>), 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<Vector128<Byte>>(_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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<SByte>>(_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<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), 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<SByte>), 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<Vector128<SByte>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), 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<Byte>), 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<Vector128<Byte>>(_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<Vector128<Int16>>(_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<Int16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), 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<Int16>), 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<Vector128<Int16>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<SByte>>(_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<SByte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), 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<SByte>), 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<Vector128<SByte>>(_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<Vector128<UInt16>>(_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<UInt16>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), 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<UInt16>), 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<Vector128<UInt16>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Byte>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Double>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Double>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<SByte>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<SByte>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var secondOp = Unsafe.Read<Vector128<Single>>(_dataTable.inArray2Ptr);
             var thirdOp = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector128<Double>>(_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<Vector128<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<UInt64>), typeof(Vector128<UInt64>) })
                                      .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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), 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<Byte>), 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<Vector128<Byte>>(_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<Vector128<Byte>>(_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<Byte>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), 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<Byte>), 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<Vector128<Byte>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int32>>(_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<Int32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<Int64>>(_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<Int64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<Single>>(_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<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), 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<Single>), 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<Vector128<Single>>(_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<Vector128<Single>>(_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<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), 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<Single>), 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<Vector128<Single>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector128<Double>>(_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<Vector128<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Byte>>(_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<Byte>), typeof(Byte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), 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<Byte>), 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<Vector128<Byte>>(_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<Vector128<Byte>>(_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<Byte>), typeof(Byte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), 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<Byte>), 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<Vector128<Byte>>(_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<Vector128<Int32>>(_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<Int32>), typeof(Int32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int32>>(_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<Int32>), typeof(Int32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), 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<Int32>), 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<Vector128<Int32>>(_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<Vector128<Int64>>(_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<Int64>), typeof(Int64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<Int64>>(_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<Int64>), typeof(Int64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), 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<Int64>), 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<Vector128<Int64>>(_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<Vector128<SByte>>(_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<SByte>), typeof(SByte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), 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<SByte>), 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<Vector128<SByte>>(_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<Vector128<SByte>>(_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<SByte>), typeof(SByte), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), 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<SByte>), 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<Vector128<SByte>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>), 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<Single>), typeof(Vector128<Single>), 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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(UInt32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt32>>(_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<UInt32>), typeof(UInt32), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), 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<UInt32>), 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<Vector128<UInt32>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(UInt64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<UInt64>>(_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<UInt64>), typeof(UInt64), typeof(byte) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), 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<UInt64>), 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<Vector128<UInt64>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<UInt16>), typeof(Vector128<UInt16>) })
                                      .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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<UInt32>), typeof(Vector128<UInt32>) })
                                      .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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector128<Double>>(_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<Vector128<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector128<Double>>(_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<Vector128<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector128<Double>>(_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<Vector128<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector128<Double>>(_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<Vector128<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Double>>(_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<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>) })
                                      .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<Double>) })
                                      .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<Vector128<Double>>(_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<Vector128<Single>>(_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<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>) })
                                      .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<Single>) })
                                      .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<Vector128<Single>>(_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<Vector128<Double>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Double>>(_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<Double>), typeof(Vector128<Double>) })
                                      .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<Double>), typeof(Vector128<Double>) })
                                      .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<Vector128<Double>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Double>>(_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<Vector128<Single>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Single>>(_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<Single>), typeof(Vector128<Single>) })
                                      .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<Single>), typeof(Vector128<Single>) })
                                      .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<Vector128<Single>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Single>>(_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<Vector128<Byte>>(_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<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>) })
                                      .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<Byte>) })
                                      .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<Vector128<Byte>>(_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<Vector128<Int16>>(_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<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>) })
                                      .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<Int16>) })
                                      .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<Vector128<Int16>>(_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<Vector128<Int32>>(_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<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>) })
                                      .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<Int32>) })
                                      .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<Vector128<Int32>>(_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<Vector128<Int64>>(_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<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>) })
                                      .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<Int64>) })
                                      .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<Vector128<Int64>>(_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<Vector128<SByte>>(_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<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>) })
                                      .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<SByte>) })
                                      .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<Vector128<SByte>>(_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<Vector128<UInt16>>(_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<UInt16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt16>>(_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<UInt16>) })
                                      .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<UInt16>) })
                                      .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<Vector128<UInt16>>(_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<Vector128<UInt32>>(_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<UInt32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt32>>(_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<UInt32>) })
                                      .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<UInt32>) })
                                      .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<Vector128<UInt32>>(_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<Vector128<UInt64>>(_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<UInt64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<UInt64>>(_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<UInt64>) })
                                      .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<UInt64>) })
                                      .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<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<Byte>), typeof(Vector128<Byte>) });
 
             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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) });
 
             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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) });
 
             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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) });
 
             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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) });
 
             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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) });
 
             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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) });
 
             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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestMixOnesZeros), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) });
 
             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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<Byte>), typeof(Vector128<Byte>) });
 
             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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<Int16>), typeof(Vector128<Int16>) });
 
             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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<Int32>), typeof(Vector128<Int32>) });
 
             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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<Int64>), typeof(Vector128<Int64>) });
 
             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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<SByte>), typeof(Vector128<SByte>) });
 
             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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<UInt16>), typeof(Vector128<UInt16>) });
 
             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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<UInt32>), typeof(Vector128<UInt32>) });
 
             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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
+        {
+            TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
+
+            var method = typeof(Sse41).GetMethod(nameof(Sse41.TestNotZAndNotC), new Type[] { typeof(Vector128<UInt64>), typeof(Vector128<UInt64>) });
 
             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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Byte>), typeof(Vector128<Byte>) });
 
             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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Int16>), typeof(Vector128<Int16>) });
 
             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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Int32>), typeof(Vector128<Int32>) });
 
             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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Int64>), typeof(Vector128<Int64>) });
 
             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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<SByte>), typeof(Vector128<SByte>) });
 
             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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<UInt16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt16>>(_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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<UInt16>), typeof(Vector128<UInt16>) });
 
             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<Vector128<UInt16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt16>>(_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<Vector128<UInt32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt32>>(_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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<UInt32>), typeof(Vector128<UInt32>) });
 
             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<Vector128<UInt32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt32>>(_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<Vector128<UInt64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<UInt64>>(_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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<UInt64>), typeof(Vector128<UInt64>) });
 
             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<Vector128<UInt64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<UInt64>>(_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<Vector128<Int64>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int64>>(_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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Int64>), typeof(Vector128<Int64>) })
                                      .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<Vector128<Int64>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int64>>(_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<Vector128<SByte>>(_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<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>) })
                                      .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<SByte>) })
                                      .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<Vector128<SByte>>(_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<Vector128<Int16>>(_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<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>) })
                                      .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<Int16>) })
                                      .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<Vector128<Int16>>(_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<Vector128<Int32>>(_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<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>) })
                                      .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<Int32>) })
                                      .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<Vector128<Int32>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<Byte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<SByte>) })
                                      .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<Byte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Byte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Byte>>(_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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Byte>), typeof(Vector128<Byte>) })
                                      .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<Vector128<Byte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Byte>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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<Vector128<Int16>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int16>>(_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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Int16>), typeof(Vector128<Int16>) })
                                      .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<Vector128<Int16>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int16>>(_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<Vector128<Int32>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<Int32>>(_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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Int32>), typeof(Vector128<Int32>) })
                                      .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<Vector128<Int32>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<Int32>>(_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<Vector128<SByte>>(_dataTable.inArray1Ptr),
                 Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .Invoke(null, new object[] {
                                         Unsafe.Read<Vector128<SByte>>(_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<SByte>), typeof(Vector128<SByte>) })
                                      .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<SByte>), typeof(Vector128<SByte>) })
                                      .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<Vector128<SByte>>(_dataTable.inArray1Ptr);
             var right = Unsafe.Read<Vector128<SByte>>(_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