Modify iteration behavior some benchmarks

This change updates the iteration behavior for the following benchmarks, so that
they generally run for about 1 second per iteration:
* Inline/InlineGCStruct
* Inline/NoThrowInline
* Span/IndexerBench/Indexer4
* Functions/MathTests/*

It also removes the length 1, 10, and 1000 variants of the Span/SpanBench
tests, leaving just the length 100 variants. Analysis has shown that there
is no need to test varying lengths here. Iteration counts for these tests
have been left as is and will be fixed subsequently.

Partially addresses #11654.

19 files changed, 95 insertions, 38 deletions

diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AbsSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AbsSingle.cs
index 8100c37e1d..1f2d280882 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AbsSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AbsSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float absSingleDelta = 0.0004f;
         private const float absSingleExpectedResult = 2500.03125f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = AbsSingleIterations)]
         public static void AbsSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    AbsSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        AbsSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AcosSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AcosSingle.cs
index b958cc1bb4..d71e95167a 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AcosSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AcosSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float acosSingleDelta = 0.0004f;
         private const float acosSingleExpectedResult = 7852.41084f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = AcosSingleIterations)]
         public static void AcosSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    AcosSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        AcosSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AsinSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AsinSingle.cs
index 917c49288f..e6d203f040 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AsinSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AsinSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float asinSingleDelta = 0.0004f;
         private const float asinSingleExpectedResult = 1.57079590f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = AsinSingleIterations)]
         public static void AsinSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    AsinSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        AsinSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Atan2Single.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Atan2Single.cs
index a3a4577947..5bee16d4ef 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Atan2Single.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Atan2Single.cs
@@ -15,14 +15,17 @@ namespace Functions
         private const float atan2SingleDeltaY = 0.0004f;
         private const float atan2SingleExpectedResult = 3930.14282f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = Atan2SingleIterations)]
         public static void Atan2SingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    Atan2SingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        Atan2SingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AtanSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AtanSingle.cs
index 95cc0e226e..0a5be9edaf 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AtanSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/AtanSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float atanSingleDelta = 0.0004f;
         private const float atanSingleExpectedResult = 0.841940999f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = AtanSingleIterations)]
         public static void AtanSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    AtanSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        AtanSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CeilingSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CeilingSingle.cs
index 85454f1cc8..0ab25366c7 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CeilingSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CeilingSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float ceilingSingleDelta = 0.0004f;
         private const float ceilingSingleExpectedResult = 2502.0f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = CeilingSingleIterations)]
         public static void CeilingSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    CeilingSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        CeilingSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CosSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CosSingle.cs
index 3d1d6a3b58..ab43ea9140 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CosSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CosSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float cosSingleDelta = 0.000628318531f;
         private const float cosSingleExpectedResult = -0.993487537f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = CosSingleIterations)]
         public static void CosSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    CosSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        CosSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CoshSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CoshSingle.cs
index 072a0dcf66..0f223f553e 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CoshSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/CoshSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float coshSingleDelta = 0.0004f;
         private const float coshSingleExpectedResult = 5876.02588f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = CoshSingleIterations)]
         public static void CoshSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    CoshSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        CoshSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/ExpSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/ExpSingle.cs
index e9d61c9f5d..b6d9d1d512 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/ExpSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/ExpSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float expSingleDelta = 0.0004f;
         private const float expSingleExpectedResult = 5877.28564f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = ExpSingleIterations)]
         public static void ExpSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    ExpSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        ExpSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/FloorSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/FloorSingle.cs
index ce1febb178..0b2dd0403d 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/FloorSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/FloorSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float floorSingleDelta = 0.0004f;
         private const float floorSingleExpectedResult = -2498.0f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = FloorSingleIterations)]
         public static void FloorSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    FloorSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        FloorSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Log10Single.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Log10Single.cs
index 80f00b3ec8..3c6ef0c9ef 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Log10Single.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/Log10Single.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float log10SingleDelta = 0.0004f;
         private const float log10SingleExpectedResult = -664.094971f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = Log10SingleIterations)]
         public static void Log10SingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    Log10SingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        Log10SingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/LogSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/LogSingle.cs
index 3f07ef16ab..0a8c8a58d2 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/LogSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/LogSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float logSingleDelta = 0.0004f;
         private const float logSingleExpectedResult = -1529.14014f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = LogSingleIterations)]
         public static void LogSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    LogSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        LogSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/PowSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/PowSingle.cs
index 49de8a0101..6d47c6f75e 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/PowSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/PowSingle.cs
@@ -15,14 +15,17 @@ namespace Functions
         private const float powSingleDeltaY = 0.0004f;
         private const float powSingleExpectedResult = 4659.30762f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = PowSingleIterations)]
         public static void PowSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    PowSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        PowSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/RoundSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/RoundSingle.cs
index b494a2a985..ca04ba0106 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/RoundSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/RoundSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float roundSingleDelta = 0.000628318531f;
         private const float roundSingleExpectedResult = 2.0f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = RoundSingleIterations)]
         public static void RoundSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    RoundSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        RoundSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinSingle.cs
index 4d6228361e..71448703ea 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float sinSingleDelta = 0.000628318531f;
         private const float sinSingleExpectedResult = 1.03592682f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = SinSingleIterations)]
         public static void SinSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    SinSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        SinSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinhSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinhSingle.cs
index 9ed01e4f55..0dcbdc1499 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinhSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SinhSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float sinhSingleDelta = 0.0004f;
         private const float sinhSingleExpectedResult = 1.26028216f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = SinhSingleIterations)]
         public static void SinhSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    SinhSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        SinhSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SqrtSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SqrtSingle.cs
index f7349c1a5f..62b493ff48 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SqrtSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/SqrtSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float sqrtSingleDelta = 0.000628318531f;
         private const float sqrtSingleExpectedResult = 5909.03027f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = SqrtSingleIterations)]
         public static void SqrtSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    SqrtSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        SqrtSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanSingle.cs
index b81050bfa3..ec2b9a0acb 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float tanSingleDelta = 0.0004f;
         private const float tanSingleExpectedResult = 1.66717815f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = TanSingleIterations)]
         public static void TanSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    TanSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        TanSingleTest();
+                    }
                 }
             }
         }
diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanhSingle.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanhSingle.cs
index 160e1135bf..10cb7e1cea 100644
--- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanhSingle.cs
+++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Single/TanhSingle.cs
@@ -14,14 +14,17 @@ namespace Functions
         private const float tanhSingleDelta = 0.0004f;
         private const float tanhSingleExpectedResult = 0.816701353f;
 
-        [Benchmark]
+        [Benchmark(InnerIterationCount = TanhSingleIterations)]
         public static void TanhSingleBenchmark()
         {
             foreach (var iteration in Benchmark.Iterations)
             {
                 using (iteration.StartMeasurement())
                 {
-                    TanhSingleTest();
+                    for (int i = 0; i < Benchmark.InnerIterationCount; i++)
+                    {
+                        TanhSingleTest();
+                    }
                 }
             }
         }