diff options
43 files changed, 245 insertions, 185 deletions
diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.cs index 1439c77dd9..951ceced99 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/InlineGCStruct.cs @@ -28,7 +28,7 @@ public class InlineGCStruct #if DEBUG public const int Iterations = 1; #else - public const int Iterations = 2500000; + public const int Iterations = 350000000; #endif [MethodImpl(MethodImplOptions.NoInlining)] @@ -73,7 +73,7 @@ public class InlineGCStruct return param * 2; } - [Benchmark] + [Benchmark(InnerIterationCount = Iterations)] public static bool WithFormat() { int result = 0; @@ -82,7 +82,7 @@ public class InlineGCStruct { using (iteration.StartMeasurement()) { - for (int i = 0; i < Iterations; i++) + for (int i = 0; i < Benchmark.InnerIterationCount; i++) { result |= FastFunctionNotCallingStringFormat(11); } @@ -92,7 +92,7 @@ public class InlineGCStruct return (result == 22); } - [Benchmark] + [Benchmark(InnerIterationCount = Iterations)] public static bool WithoutFormat() { int result = 0; @@ -101,7 +101,7 @@ public class InlineGCStruct { using (iteration.StartMeasurement()) { - for (int i = 0; i < Iterations; i++) + for (int i = 0; i < Benchmark.InnerIterationCount; i++) { result |= FastFunctionNotHavingStringFormat(11); } diff --git a/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs b/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs index f28d4caf81..2e9144d1e5 100644 --- a/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs +++ b/tests/src/JIT/Performance/CodeQuality/Inlining/NoThrowInline.cs @@ -19,7 +19,7 @@ public static class NoThrowInline #if DEBUG public const int Iterations = 1; #else - public const int Iterations = 100000000; + public const int Iterations = 275000000; #endif static void ThrowIfNull(string s) @@ -57,14 +57,17 @@ public static class NoThrowInline return a.Length + b.Length + c.Length + d.Length; } - [Benchmark] + [Benchmark(InnerIterationCount = Iterations)] public static void Test() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - Bench("a", "bc", "def", "ghij"); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + Bench("a", "bc", "def", "ghij"); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AbsDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AbsDouble.cs index f5650ab2c7..1bb59a7b0a 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AbsDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AbsDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double absDoubleDelta = 0.0004; private const double absDoubleExpectedResult = 2499.9999999999659; - [Benchmark] + [Benchmark(InnerIterationCount=AbsDoubleIterations)] public static void AbsDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - AbsDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + AbsDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AcosDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AcosDouble.cs index 4df08bd063..8e5f2ca316 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AcosDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AcosDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double acosDoubleDelta = 0.0004; private const double acosDoubleExpectedResult = 7852.4108380716079; - [Benchmark] + [Benchmark(InnerIterationCount=AcosDoubleIterations)] public static void AcosDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - AcosDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + AcosDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AsinDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AsinDouble.cs index e20b65c422..e5231db99c 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AsinDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AsinDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double asinDoubleDelta = 0.0004; private const double asinDoubleExpectedResult = 1.5707959028763392; - [Benchmark] + [Benchmark(InnerIterationCount = AsinDoubleIterations)] public static void AsinDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - AsinDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + AsinDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Atan2Double.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Atan2Double.cs index 1fcde440af..1ca42857f5 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Atan2Double.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Atan2Double.cs @@ -15,14 +15,17 @@ namespace Functions private const double atan2DoubleDeltaY = 0.0004; private const double atan2DoubleExpectedResult = 3926.99081698702; - [Benchmark] + [Benchmark(InnerIterationCount = Atan2DoubleIterations)] public static void Atan2DoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - Atan2DoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + Atan2DoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AtanDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AtanDouble.cs index 28619e8527..c4b5ddd9eb 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AtanDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/AtanDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double atanDoubleDelta = 0.0004; private const double atanDoubleExpectedResult = 0.78539816322061329; - [Benchmark] + [Benchmark(InnerIterationCount = AtanDoubleIterations)] public static void AtanDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - AtanDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + AtanDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CeilingDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CeilingDouble.cs index e28e9e67a5..a3037c8ebb 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CeilingDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CeilingDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double ceilingDoubleDelta = 0.0004; private const double ceilingDoubleExpectedResult = 2500; - [Benchmark] + [Benchmark(InnerIterationCount = CeilingDoubleIterations)] public static void CeilingDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - CeilingDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + CeilingDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CosDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CosDouble.cs index faf69b0439..3bea5f3cc5 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CosDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CosDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double cosDoubleDelta = 0.0006283185307180; private const double cosDoubleExpectedResult = -1.0000000005924159; - [Benchmark] + [Benchmark(InnerIterationCount = CosDoubleIterations)] public static void CosDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - CosDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + CosDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CoshDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CoshDouble.cs index 3a7e36d107..628737a3b9 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CoshDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/CoshDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double coshDoubleDelta = 0.0004; private const double coshDoubleExpectedResult = 5876.0060465657216; - [Benchmark] + [Benchmark(InnerIterationCount = CoshDoubleIterations)] public static void CoshDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - CoshDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + CoshDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/ExpDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/ExpDouble.cs index 9af1cb8e8b..05607eafa0 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/ExpDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/ExpDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double expDoubleDelta = 0.0004; private const double expDoubleExpectedResult = 5877.1812477590884; - [Benchmark] + [Benchmark(InnerIterationCount = ExpDoubleIterations)] public static void ExpDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - ExpDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + ExpDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/FloorDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/FloorDouble.cs index 158cc490df..45d9848a39 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/FloorDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/FloorDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double floorDoubleDelta = 0.0004; private const double floorDoubleExpectedResult = -2500; - [Benchmark] + [Benchmark(InnerIterationCount = FloorDoubleIterations)] public static void FloorDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - FloorDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + FloorDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Log10Double.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Log10Double.cs index 32cd2163a5..9b05b154fd 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Log10Double.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/Log10Double.cs @@ -14,14 +14,17 @@ namespace Functions private const double log10DoubleDelta = 0.0004; private const double log10DoubleExpectedResult = -664.07384902184072; - [Benchmark] + [Benchmark(InnerIterationCount = Log10DoubleIterations)] public static void Log10DoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - Log10DoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + Log10DoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/LogDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/LogDouble.cs index 38edbfbbd9..12992d417a 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/LogDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/LogDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double logDoubleDelta = 0.0004; private const double logDoubleExpectedResult = -1529.0865454048721; - [Benchmark] + [Benchmark(InnerIterationCount = LogDoubleIterations)] public static void LogDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - LogDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + LogDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/PowDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/PowDouble.cs index f36d84e179..5847709cc4 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/PowDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/PowDouble.cs @@ -15,14 +15,17 @@ namespace Functions private const double powDoubleDeltaY = 0.0004; private const double powDoubleExpectedResult = 4659.4627376138733; - [Benchmark] + [Benchmark(InnerIterationCount = PowDoubleIterations)] public static void PowDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - PowDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + PowDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/RoundDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/RoundDouble.cs index 6c7a46992a..ac91a3d388 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/RoundDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/RoundDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double roundDoubleDelta = 0.0006283185307180; private const double roundDoubleExpectedResult = 2; - [Benchmark] + [Benchmark(InnerIterationCount = RoundDoubleIterations)] public static void RoundDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - RoundDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + RoundDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinDouble.cs index c684b9530b..2c856d79d4 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double sinDoubleDelta = 0.0006283185307180; private const double sinDoubleExpectedResult = 1.0000000005445053; - [Benchmark] + [Benchmark(InnerIterationCount = SinDoubleIterations)] public static void SinDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - SinDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + SinDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinhDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinhDouble.cs index 69d1cb80da..75d1d104ac 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinhDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SinhDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double sinhDoubleDelta = 0.0004; private const double sinhDoubleExpectedResult = 1.17520119337903; - [Benchmark] + [Benchmark(InnerIterationCount = SinhDoubleIterations)] public static void SinhDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - SinhDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + SinhDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SqrtDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SqrtDouble.cs index 59e73b3fcb..0738dc8520 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SqrtDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/SqrtDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double sqrtDoubleDelta = 0.0006283185307180; private const double sqrtDoubleExpectedResult = 5909.0605337797215; - [Benchmark] + [Benchmark(InnerIterationCount = SqrtDoubleIterations)] public static void SqrtDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - SqrtDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + SqrtDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanDouble.cs index 123948419f..f5639e052b 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double tanDoubleDelta = 0.0004; private const double tanDoubleExpectedResult = 1.5574077243051505; - [Benchmark] + [Benchmark(InnerIterationCount = TanDoubleIterations)] public static void TanDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - TanDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + TanDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanhDouble.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanhDouble.cs index 526a428069..290e251294 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanhDouble.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/Double/TanhDouble.cs @@ -14,14 +14,17 @@ namespace Functions private const double tanhDoubleDelta = 0.0004; private const double tanhDoubleExpectedResult = 0.76159415578341827; - [Benchmark] + [Benchmark(InnerIterationCount = TanhDoubleIterations)] public static void TanhDoubleBenchmark() { foreach (var iteration in Benchmark.Iterations) { using (iteration.StartMeasurement()) { - TanhDoubleTest(); + for (int i = 0; i < Benchmark.InnerIterationCount; i++) + { + TanhDoubleTest(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Math/Functions/MathTests.cs b/tests/src/JIT/Performance/CodeQuality/Math/Functions/MathTests.cs index b738c75352..c203cc0dff 100644 --- a/tests/src/JIT/Performance/CodeQuality/Math/Functions/MathTests.cs +++ b/tests/src/JIT/Performance/CodeQuality/Math/Functions/MathTests.cs @@ -25,5 +25,47 @@ namespace Functions // of the perf testing as it ensures we get the expected value and that it is at least as precise // as we would have computed with the half-precision version of the function (without aggregation). private const float singleEpsilon = 9.77e-04f; + + // While iterations covers the domain of inputs, the full span of results doesn't run long enough + // to meet our siginificance criteria. So each test is repeated many times, using the factors below. + private const int AbsDoubleIterations = 200000; + private const int AcosDoubleIterations = 10000; + private const int AsinDoubleIterations = 10000; + private const int Atan2DoubleIterations = 6500; + private const int AtanDoubleIterations = 13000; + private const int CeilingDoubleIterations = 80000; + private const int CosDoubleIterations = 16000; + private const int CoshDoubleIterations = 8000; + private const int ExpDoubleIterations = 16000; + private const int FloorDoubleIterations = 80000; + private const int Log10DoubleIterations = 16000; + private const int LogDoubleIterations = 20000; + private const int PowDoubleIterations = 4000; + private const int RoundDoubleIterations = 35000; + private const int SinDoubleIterations = 16000; + private const int SinhDoubleIterations = 8000; + private const int SqrtDoubleIterations = 40000; + private const int TanDoubleIterations = 16000; + private const int TanhDoubleIterations = 17000; + + private const int AbsSingleIterations = 200000; + private const int AcosSingleIterations = 15000; + private const int AsinSingleIterations = 15000; + private const int Atan2SingleIterations = 9000; + private const int AtanSingleIterations = 17000; + private const int CeilingSingleIterations = 80000; + private const int CosSingleIterations = 20000; + private const int CoshSingleIterations = 10000; + private const int ExpSingleIterations = 24000; + private const int FloorSingleIterations = 80000; + private const int Log10SingleIterations = 20000; + private const int LogSingleIterations = 30000; + private const int PowSingleIterations = 10000; + private const int RoundSingleIterations = 35000; + private const int SinSingleIterations = 20000; + private const int SinhSingleIterations = 10000; + private const int SqrtSingleIterations = 80000; + private const int TanSingleIterations = 25000; + private const int TanhSingleIterations = 20000; } } 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(); + } } } } diff --git a/tests/src/JIT/Performance/CodeQuality/Span/Indexer.cs b/tests/src/JIT/Performance/CodeQuality/Span/Indexer.cs index c7f4846548..63f59e04be 100644 --- a/tests/src/JIT/Performance/CodeQuality/Span/Indexer.cs +++ b/tests/src/JIT/Performance/CodeQuality/Span/Indexer.cs @@ -267,7 +267,7 @@ namespace Span { Span<byte> s = new Span<byte>(a); byte result = 0; - int inner = Math.Max(1, (innerIterationCount / 10)); + int inner = Math.Max(1, innerIterationCount); for (int i = 0; i < inner ; ++i) { result = TestIndexer4(s, 10); diff --git a/tests/src/JIT/Performance/CodeQuality/Span/SpanBench.cs b/tests/src/JIT/Performance/CodeQuality/Span/SpanBench.cs index ef694421ef..5cb838fab9 100644 --- a/tests/src/JIT/Performance/CodeQuality/Span/SpanBench.cs +++ b/tests/src/JIT/Performance/CodeQuality/Span/SpanBench.cs @@ -438,20 +438,14 @@ namespace Span #region TestSpanConstructor<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanConstructorByte(int length) { InvokeTestSpanConstructor<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations / 100)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanConstructorString(int length) { InvokeTestSpanConstructor<string>(length); @@ -483,20 +477,14 @@ namespace Span #region TestSpanDangerousCreate<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanDangerousCreateByte(int length) { InvokeTestSpanDangerousCreate<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanDangerousCreateString(int length) { InvokeTestSpanDangerousCreate<string>(length); @@ -529,20 +517,14 @@ namespace Span #region TestSpanDangerousGetPinnableReference<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanDangerousGetPinnableReferenceByte(int length) { InvokeTestSpanDangerousGetPinnableReference<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanDangerousGetPinnableReferenceString(int length) { InvokeTestSpanDangerousGetPinnableReference<string>(length); @@ -572,20 +554,14 @@ namespace Span #region TestSpanIndexHoistable<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanIndexHoistableByte(int length) { InvokeTestSpanIndexHoistable<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanIndexHoistableString(int length) { InvokeTestSpanIndexHoistable<string>(length); @@ -612,20 +588,14 @@ namespace Span #region TestArrayIndexHoistable<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayIndexHoistableByte(int length) { InvokeTestArrayIndexHoistable<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayIndexHoistableString(int length) { InvokeTestArrayIndexHoistable<string>(length); @@ -650,20 +620,14 @@ namespace Span #region TestSpanIndexVariant<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanIndexVariantByte(int length) { InvokeTestSpanIndexVariant<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanIndexVariantString(int length) { InvokeTestSpanIndexVariant<string>(length); @@ -691,20 +655,14 @@ namespace Span #region TestArrayIndexVariant<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayIndexVariantByte(int length) { InvokeTestArrayIndexVariant<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayIndexVariantString(int length) { InvokeTestArrayIndexVariant<string>(length); @@ -733,20 +691,14 @@ namespace Span #region TestSpanSlice<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanSliceByte(int length) { InvokeTestSpanSlice<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanSliceString(int length) { InvokeTestSpanSlice<string>(length); @@ -779,20 +731,14 @@ namespace Span #region TestSpanToArray<T> [Benchmark(InnerIterationCount = BaseIterations / 100)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanToArrayByte(int length) { InvokeTestSpanToArray<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations / 100)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanToArrayString(int length) { InvokeTestSpanToArray<string>(length); @@ -819,20 +765,14 @@ namespace Span #region TestSpanCopyTo<T> [Benchmark(InnerIterationCount = BaseIterations / 10)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanCopyToByte(int length) { InvokeTestSpanCopyTo<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations / 100)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanCopyToString(int length) { InvokeTestSpanCopyTo<string>(length); @@ -860,20 +800,14 @@ namespace Span #region TestArrayCopyTo<T> [Benchmark(InnerIterationCount = BaseIterations / 10)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayCopyToByte(int length) { InvokeTestArrayCopyTo<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations / 100)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayCopyToString(int length) { InvokeTestArrayCopyTo<string>(length); @@ -898,20 +832,14 @@ namespace Span #region TestSpanFill<T> [Benchmark(InnerIterationCount = BaseIterations * 10)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanFillByte(int length) { InvokeTestSpanFill<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations / 100)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanFillString(int length) { InvokeTestSpanFill<string>(length); @@ -936,20 +864,14 @@ namespace Span #region TestSpanClear<T> [Benchmark(InnerIterationCount = BaseIterations / 10)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanClearByte(int length) { InvokeTestSpanClear<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations / 10)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanClearString(int length) { InvokeTestSpanClear<string>(length); @@ -974,20 +896,14 @@ namespace Span #region TestArrayClear<T> [Benchmark(InnerIterationCount = BaseIterations / 10)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayClearByte(int length) { InvokeTestArrayClear<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations / 10)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestArrayClearString(int length) { InvokeTestArrayClear<string>(length); @@ -1011,20 +927,14 @@ namespace Span #region TestSpanAsBytes<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanAsBytesByte(int length) { InvokeTestSpanAsBytes<byte>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanAsBytesInt(int length) { InvokeTestSpanAsBytes<int>(length); @@ -1059,20 +969,14 @@ namespace Span #region TestSpanNonPortableCast<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanNonPortableCastFromByteToInt(int length) { InvokeTestSpanNonPortableCast<byte, int>(length); } [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanNonPortableCastFromIntToByte(int length) { InvokeTestSpanNonPortableCast<int, byte>(length); @@ -1110,10 +1014,7 @@ namespace Span #region TestSpanAsSpanStringChar<T> [Benchmark(InnerIterationCount = BaseIterations)] - [InlineData(1)] - [InlineData(10)] [InlineData(100)] - [InlineData(1000)] public static void TestSpanAsSpanStringCharWrapper(int length) { StringBuilder sb = new StringBuilder(); @@ -1190,4 +1091,4 @@ namespace Span return 100; } } -}
\ No newline at end of file +} |