Benchmarks: show results per single operation

roji · roji · commit aeee2bc9cc44 · 2020-05-02T20:02:53.000+02:00
Fixes dotnet#19875
diff --git a/benchmark/EFCore.Benchmarks/ChangeTracker/DbSetOperationTests.cs b/benchmark/EFCore.Benchmarks/ChangeTracker/DbSetOperationTests.cs
@@ -15,6 +15,8 @@ public class DbSetOperationTests
     {
         public abstract class DbSetOperationBase
         {
+            public const int OperationsPerInvoke = 20000;
+
             private OrdersFixtureBase _fixture;
 
             protected List<Customer> _customersWithoutPk;
@@ -31,8 +33,8 @@ public virtual void CreateCustomers()
             {
                 _fixture = CreateFixture();
                 _fixture.Initialize(0, 0, 0, 0);
-                _customersWithoutPk = _fixture.CreateCustomers(20000, setPrimaryKeys: false);
-                _customersWithPk = _fixture.CreateCustomers(20000, setPrimaryKeys: true);
+                _customersWithoutPk = _fixture.CreateCustomers(OperationsPerInvoke, setPrimaryKeys: false);
+                _customersWithPk = _fixture.CreateCustomers(OperationsPerInvoke, setPrimaryKeys: true);
             }
 
             public virtual void InitializeContext()
@@ -56,7 +58,7 @@ public override void InitializeContext()
                 base.InitializeContext();
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void Add()
             {
                 foreach (var customer in _customersWithoutPk)
@@ -65,13 +67,13 @@ public virtual void Add()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void AddRange()
             {
                 _context.Customers.AddRange(_customersWithoutPk);
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void Attach()
             {
                 foreach (var customer in _customersWithPk)
@@ -80,7 +82,7 @@ public virtual void Attach()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void AttachRange()
             {
                 _context.Customers.AttachRange(_customersWithPk);
@@ -96,7 +98,7 @@ public override void InitializeContext()
                 _context.Customers.AttachRange(_customersWithPk);
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void Remove()
             {
                 foreach (var customer in _customersWithPk)
@@ -105,13 +107,13 @@ public virtual void Remove()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void RemoveRange()
             {
                 _context.Customers.RemoveRange(_customersWithPk);
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void Update()
             {
                 foreach (var customer in _customersWithPk)
@@ -120,7 +122,7 @@ public virtual void Update()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
             public virtual void UpdateRange()
             {
                 _context.Customers.UpdateRange(_customersWithPk);
diff --git a/benchmark/EFCore.Benchmarks/ChangeTracker/FixupTests.cs b/benchmark/EFCore.Benchmarks/ChangeTracker/FixupTests.cs
@@ -17,6 +17,10 @@ public class FixupTests
     {
         public abstract class FixupBase
         {
+            protected const int Customers = 5000;
+            protected const int OrdersPerCustomer = 2;
+            protected const int TotalOrders = Customers * OrdersPerCustomer;
+
             private OrdersFixtureBase _fixture;
 
             protected List<Customer> _customers;
@@ -33,12 +37,12 @@ public abstract class FixupBase
             public virtual void CheckData()
             {
                 _fixture = CreateFixture();
-                _fixture.Initialize(0, 5000, 2, 0);
+                _fixture.Initialize(0, Customers, OrdersPerCustomer, 0);
 
                 using (var context = _fixture.CreateContext())
                 {
-                    Assert.Equal(5000, context.Customers.Count());
-                    Assert.Equal(10000, context.Orders.Count());
+                    Assert.Equal(Customers, context.Customers.Count());
+                    Assert.Equal(TotalOrders, context.Orders.Count());
                 }
             }
 
@@ -47,9 +51,9 @@ public virtual void InitializeContext()
                 _context = _fixture.CreateContext();
                 _context.ChangeTracker.AutoDetectChangesEnabled = AutoDetectChanges;
 
-                _customers = _fixture.CreateCustomers(5000, setPrimaryKeys: true);
-                _ordersWithoutPk = _fixture.CreateOrders(_customers, ordersPerCustomer: 2, setPrimaryKeys: false);
-                _ordersWithPk = _fixture.CreateOrders(_customers, ordersPerCustomer: 2, setPrimaryKeys: true);
+                _customers = _fixture.CreateCustomers(Customers, setPrimaryKeys: true);
+                _ordersWithoutPk = _fixture.CreateOrders(_customers, ordersPerCustomer: OrdersPerCustomer, setPrimaryKeys: false);
+                _ordersWithPk = _fixture.CreateOrders(_customers, ordersPerCustomer: OrdersPerCustomer, setPrimaryKeys: true);
             }
 
             [IterationCleanup]
@@ -68,7 +72,7 @@ public override void InitializeContext()
                 _context.Customers.AttachRange(_customers);
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = TotalOrders)]
             public virtual void AddChildren()
             {
                 foreach (var order in _ordersWithoutPk)
@@ -77,7 +81,7 @@ public virtual void AddChildren()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = TotalOrders)]
             public virtual void AttachChildren()
             {
                 foreach (var order in _ordersWithPk)
@@ -86,7 +90,7 @@ public virtual void AttachChildren()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = TotalOrders)]
             public virtual void QueryChildren()
             {
                 _context.Orders.ToList();
@@ -102,7 +106,7 @@ public override void InitializeContext()
                 _context.Orders.AttachRange(_ordersWithPk);
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = Customers)]
             public virtual void AddParents()
             {
                 foreach (var customer in _customers)
@@ -111,7 +115,7 @@ public virtual void AddParents()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = Customers)]
             public virtual void AttachParents()
             {
                 foreach (var customer in _customers)
@@ -120,7 +124,7 @@ public virtual void AttachParents()
                 }
             }
 
-            [Benchmark]
+            [Benchmark(OperationsPerInvoke = Customers)]
             public virtual void QueryParents()
             {
                 _context.Customers.ToList();
diff --git a/benchmark/EFCore.Benchmarks/Extensions/Extensions.cs b/benchmark/EFCore.Benchmarks/Extensions/Extensions.cs
@@ -3,16 +3,13 @@
 
 using System.Linq;
 
+// ReSharper disable once CheckNamespace
 namespace Microsoft.EntityFrameworkCore.Benchmarks
 {
     public static class Extensions
     {
         public static IQueryable<TEntity> ApplyTracking<TEntity>(this IQueryable<TEntity> query, bool tracking)
             where TEntity : class
-        {
-            return tracking
-                ? query
-                : query.AsNoTracking();
-        }
+            => tracking ? query : query.AsNoTracking();
     }
 }
diff --git a/benchmark/EFCore.Benchmarks/Initialization/InitializationTests.cs b/benchmark/EFCore.Benchmarks/Initialization/InitializationTests.cs
@@ -15,7 +15,7 @@ public abstract class InitializationTests
         protected abstract AdventureWorksContextBase CreateContext();
         protected abstract ConventionSet CreateConventionSet();
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = 10000)]
         public virtual void CreateAndDisposeUnusedContext()
         {
             for (var i = 0; i < 10000; i++)
@@ -27,7 +27,7 @@ public virtual void CreateAndDisposeUnusedContext()
             }
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = 1000)]
         public virtual void InitializeAndQuery_AdventureWorks()
         {
             for (var i = 0; i < 1000; i++)
@@ -39,7 +39,7 @@ public virtual void InitializeAndQuery_AdventureWorks()
             }
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = 100)]
         public virtual void InitializeAndSaveChanges_AdventureWorks()
         {
             for (var i = 0; i < 100; i++)
diff --git a/benchmark/EFCore.Benchmarks/Query/FuncletizationTests.cs b/benchmark/EFCore.Benchmarks/Query/FuncletizationTests.cs
@@ -16,7 +16,8 @@ public abstract class FuncletizationTests
     {
         private OrdersContextBase _context;
 
-        protected virtual int FuncletizationIterationCount => 100;
+        public const int OperationsPerInvoke = 100;
+
         protected abstract OrdersFixtureBase CreateFixture();
 
         [GlobalSetup]
@@ -36,34 +37,34 @@ public virtual void CleanupContext()
             _context.Dispose();
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
         public virtual void NewQueryInstance()
         {
             var val = 11;
-            for (var i = 0; i < FuncletizationIterationCount; i++)
+            for (var i = 0; i < OperationsPerInvoke; i++)
             {
                 _context.Products.Where(p => p.ProductId < val).ToList();
             }
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
         public virtual void SameQueryInstance()
         {
             var val = 11;
             var query = _context.Products.Where(p => p.ProductId < val);
 
-            for (var i = 0; i < FuncletizationIterationCount; i++)
+            for (var i = 0; i < OperationsPerInvoke; i++)
             {
                 // ReSharper disable once PossibleMultipleEnumeration
                 query.ToList();
             }
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
         public virtual void ValueFromObject()
         {
             var valueHolder = new ValueHolder();
-            for (var i = 0; i < FuncletizationIterationCount; i++)
+            for (var i = 0; i < OperationsPerInvoke; i++)
             {
                 _context.Products.Where(p => p.ProductId < valueHolder.SecondLevelProperty).ToList();
             }
diff --git a/benchmark/EFCore.Benchmarks/Query/NavigationsQueryTests.cs b/benchmark/EFCore.Benchmarks/Query/NavigationsQueryTests.cs
@@ -16,8 +16,8 @@ public abstract class NavigationsQueryTests
         private AdventureWorksContextBase _context;
         private IQueryable<Store> _query;
 
-        protected virtual int QueriesPerIteration => 10;
-        protected virtual int UnfilteredCount => 466;
+        public const int OperationsPerInvoke = 10;
+        public const int UnfilteredCount = 466;
 
         [Params(true, false)]
         public bool Async { get; set; }
@@ -44,10 +44,10 @@ public virtual void CleanupContext()
             _context.Dispose();
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
         public virtual async Task PredicateAcrossOptionalNavigation()
         {
-            for (var i = 0; i < QueriesPerIteration; i++)
+            for (var i = 0; i < OperationsPerInvoke; i++)
             {
                 if (Async)
                 {
diff --git a/benchmark/EFCore.Benchmarks/Query/QueryCompilationTests.cs b/benchmark/EFCore.Benchmarks/Query/QueryCompilationTests.cs
@@ -19,6 +19,8 @@ namespace Microsoft.EntityFrameworkCore.Benchmarks.Query
     [DisplayName(nameof(QueryCompilationTests))]
     public abstract class QueryCompilationTests
     {
+        public const int OperationsPerInvoke = 10;
+
         private OrdersContextBase _context;
         private IQueryable<Product> _simpleQuery;
         private IQueryable<DTO> _complexQuery;
@@ -70,28 +72,28 @@ public virtual void CleanupContext()
             _context.Dispose();
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
         public virtual void ToList()
         {
-            for (var i = 0; i < 10; i++)
+            for (var i = 0; i < OperationsPerInvoke; i++)
             {
                 _simpleQuery.ToList();
             }
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
         public virtual void FilterOrderProject()
         {
-            for (var i = 0; i < 10; i++)
+            for (var i = 0; i < OperationsPerInvoke; i++)
             {
                 _complexQuery.ToList();
             }
         }
 
-        [Benchmark]
+        [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]
         public virtual void MultipleJoins()
         {
-            for (var i = 0; i < 10; i++)
+            for (var i = 0; i < OperationsPerInvoke; i++)
             {
                 _multipleJoinQuery.ToList();
             }

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,8 @@ public class DbSetOperationTests`
`15`	`15`	`{`
`16`	`16`	`public abstract class DbSetOperationBase`
`17`	`17`	`{`
	`18`	`+ public const int OperationsPerInvoke = 20000;`
	`19`	`+`
`18`	`20`	`private OrdersFixtureBase _fixture;`
`19`	`21`
`20`	`22`	`protected List<Customer> _customersWithoutPk;`
`@@ -31,8 +33,8 @@ public virtual void CreateCustomers()`
`31`	`33`	`{`
`32`	`34`	`_fixture = CreateFixture();`
`33`	`35`	`_fixture.Initialize(0, 0, 0, 0);`
`34`		`- _customersWithoutPk = _fixture.CreateCustomers(20000, setPrimaryKeys: false);`
`35`		`- _customersWithPk = _fixture.CreateCustomers(20000, setPrimaryKeys: true);`
	`36`	`+ _customersWithoutPk = _fixture.CreateCustomers(OperationsPerInvoke, setPrimaryKeys: false);`
	`37`	`+ _customersWithPk = _fixture.CreateCustomers(OperationsPerInvoke, setPrimaryKeys: true);`
`36`	`38`	`}`
`37`	`39`
`38`	`40`	`public virtual void InitializeContext()`
`@@ -56,7 +58,7 @@ public override void InitializeContext()`
`56`	`58`	`base.InitializeContext();`
`57`	`59`	`}`
`58`	`60`
`59`		`- [Benchmark]`
	`61`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`60`	`62`	`public virtual void Add()`
`61`	`63`	`{`
`62`	`64`	`foreach (var customer in _customersWithoutPk)`
`@@ -65,13 +67,13 @@ public virtual void Add()`
`65`	`67`	`}`
`66`	`68`	`}`
`67`	`69`
`68`		`- [Benchmark]`
	`70`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`69`	`71`	`public virtual void AddRange()`
`70`	`72`	`{`
`71`	`73`	`_context.Customers.AddRange(_customersWithoutPk);`
`72`	`74`	`}`
`73`	`75`
`74`		`- [Benchmark]`
	`76`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`75`	`77`	`public virtual void Attach()`
`76`	`78`	`{`
`77`	`79`	`foreach (var customer in _customersWithPk)`
`@@ -80,7 +82,7 @@ public virtual void Attach()`
`80`	`82`	`}`
`81`	`83`	`}`
`82`	`84`
`83`		`- [Benchmark]`
	`85`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`84`	`86`	`public virtual void AttachRange()`
`85`	`87`	`{`
`86`	`88`	`_context.Customers.AttachRange(_customersWithPk);`
`@@ -96,7 +98,7 @@ public override void InitializeContext()`
`96`	`98`	`_context.Customers.AttachRange(_customersWithPk);`
`97`	`99`	`}`
`98`	`100`
`99`		`- [Benchmark]`
	`101`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`100`	`102`	`public virtual void Remove()`
`101`	`103`	`{`
`102`	`104`	`foreach (var customer in _customersWithPk)`
`@@ -105,13 +107,13 @@ public virtual void Remove()`
`105`	`107`	`}`
`106`	`108`	`}`
`107`	`109`
`108`		`- [Benchmark]`
	`110`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`109`	`111`	`public virtual void RemoveRange()`
`110`	`112`	`{`
`111`	`113`	`_context.Customers.RemoveRange(_customersWithPk);`
`112`	`114`	`}`
`113`	`115`
`114`		`- [Benchmark]`
	`116`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`115`	`117`	`public virtual void Update()`
`116`	`118`	`{`
`117`	`119`	`foreach (var customer in _customersWithPk)`
`@@ -120,7 +122,7 @@ public virtual void Update()`
`120`	`122`	`}`
`121`	`123`	`}`
`122`	`124`
`123`		`- [Benchmark]`
	`125`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`124`	`126`	`public virtual void UpdateRange()`
`125`	`127`	`{`
`126`	`128`	`_context.Customers.UpdateRange(_customersWithPk);`
Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,10 @@ public class FixupTests`
`17`	`17`	`{`
`18`	`18`	`public abstract class FixupBase`
`19`	`19`	`{`
	`20`	`+ protected const int Customers = 5000;`
	`21`	`+ protected const int OrdersPerCustomer = 2;`
	`22`	`+ protected const int TotalOrders = Customers * OrdersPerCustomer;`
	`23`	`+`
`20`	`24`	`private OrdersFixtureBase _fixture;`
`21`	`25`
`22`	`26`	`protected List<Customer> _customers;`
`@@ -33,12 +37,12 @@ public abstract class FixupBase`
`33`	`37`	`public virtual void CheckData()`
`34`	`38`	`{`
`35`	`39`	`_fixture = CreateFixture();`
`36`		`- _fixture.Initialize(0, 5000, 2, 0);`
	`40`	`+ _fixture.Initialize(0, Customers, OrdersPerCustomer, 0);`
`37`	`41`
`38`	`42`	`using (var context = _fixture.CreateContext())`
`39`	`43`	`{`
`40`		`- Assert.Equal(5000, context.Customers.Count());`
`41`		`- Assert.Equal(10000, context.Orders.Count());`
	`44`	`+ Assert.Equal(Customers, context.Customers.Count());`
	`45`	`+ Assert.Equal(TotalOrders, context.Orders.Count());`
`42`	`46`	`}`
`43`	`47`	`}`
`44`	`48`
`@@ -47,9 +51,9 @@ public virtual void InitializeContext()`
`47`	`51`	`_context = _fixture.CreateContext();`
`48`	`52`	`_context.ChangeTracker.AutoDetectChangesEnabled = AutoDetectChanges;`
`49`	`53`
`50`		`- _customers = _fixture.CreateCustomers(5000, setPrimaryKeys: true);`
`51`		`- _ordersWithoutPk = _fixture.CreateOrders(_customers, ordersPerCustomer: 2, setPrimaryKeys: false);`
`52`		`- _ordersWithPk = _fixture.CreateOrders(_customers, ordersPerCustomer: 2, setPrimaryKeys: true);`
	`54`	`+ _customers = _fixture.CreateCustomers(Customers, setPrimaryKeys: true);`
	`55`	`+ _ordersWithoutPk = _fixture.CreateOrders(_customers, ordersPerCustomer: OrdersPerCustomer, setPrimaryKeys: false);`
	`56`	`+ _ordersWithPk = _fixture.CreateOrders(_customers, ordersPerCustomer: OrdersPerCustomer, setPrimaryKeys: true);`
`53`	`57`	`}`
`54`	`58`
`55`	`59`	`[IterationCleanup]`
`@@ -68,7 +72,7 @@ public override void InitializeContext()`
`68`	`72`	`_context.Customers.AttachRange(_customers);`
`69`	`73`	`}`
`70`	`74`
`71`		`- [Benchmark]`
	`75`	`+ [Benchmark(OperationsPerInvoke = TotalOrders)]`
`72`	`76`	`public virtual void AddChildren()`
`73`	`77`	`{`
`74`	`78`	`foreach (var order in _ordersWithoutPk)`
`@@ -77,7 +81,7 @@ public virtual void AddChildren()`
`77`	`81`	`}`
`78`	`82`	`}`
`79`	`83`
`80`		`- [Benchmark]`
	`84`	`+ [Benchmark(OperationsPerInvoke = TotalOrders)]`
`81`	`85`	`public virtual void AttachChildren()`
`82`	`86`	`{`
`83`	`87`	`foreach (var order in _ordersWithPk)`
`@@ -86,7 +90,7 @@ public virtual void AttachChildren()`
`86`	`90`	`}`
`87`	`91`	`}`
`88`	`92`
`89`		`- [Benchmark]`
	`93`	`+ [Benchmark(OperationsPerInvoke = TotalOrders)]`
`90`	`94`	`public virtual void QueryChildren()`
`91`	`95`	`{`
`92`	`96`	`_context.Orders.ToList();`
`@@ -102,7 +106,7 @@ public override void InitializeContext()`
`102`	`106`	`_context.Orders.AttachRange(_ordersWithPk);`
`103`	`107`	`}`
`104`	`108`
`105`		`- [Benchmark]`
	`109`	`+ [Benchmark(OperationsPerInvoke = Customers)]`
`106`	`110`	`public virtual void AddParents()`
`107`	`111`	`{`
`108`	`112`	`foreach (var customer in _customers)`
`@@ -111,7 +115,7 @@ public virtual void AddParents()`
`111`	`115`	`}`
`112`	`116`	`}`
`113`	`117`
`114`		`- [Benchmark]`
	`118`	`+ [Benchmark(OperationsPerInvoke = Customers)]`
`115`	`119`	`public virtual void AttachParents()`
`116`	`120`	`{`
`117`	`121`	`foreach (var customer in _customers)`
`@@ -120,7 +124,7 @@ public virtual void AttachParents()`
`120`	`124`	`}`
`121`	`125`	`}`
`122`	`126`
`123`		`- [Benchmark]`
	`127`	`+ [Benchmark(OperationsPerInvoke = Customers)]`
`124`	`128`	`public virtual void QueryParents()`
`125`	`129`	`{`
`126`	`130`	`_context.Customers.ToList();`
Original file line number	Diff line number	Diff line change
`@@ -3,16 +3,13 @@`
`3`	`3`
`4`	`4`	`using System.Linq;`
`5`	`5`
	`6`	`+// ReSharper disable once CheckNamespace`
`6`	`7`	`namespace Microsoft.EntityFrameworkCore.Benchmarks`
`7`	`8`	`{`
`8`	`9`	`public static class Extensions`
`9`	`10`	`{`
`10`	`11`	`public static IQueryable<TEntity> ApplyTracking<TEntity>(this IQueryable<TEntity> query, bool tracking)`
`11`	`12`	`where TEntity : class`
`12`		`- {`
`13`		`- return tracking`
`14`		`- ? query`
`15`		`- : query.AsNoTracking();`
`16`		`- }`
	`13`	`+ => tracking ? query : query.AsNoTracking();`
`17`	`14`	`}`
`18`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,7 +15,7 @@ public abstract class InitializationTests`
`15`	`15`	`protected abstract AdventureWorksContextBase CreateContext();`
`16`	`16`	`protected abstract ConventionSet CreateConventionSet();`
`17`	`17`
`18`		`- [Benchmark]`
	`18`	`+ [Benchmark(OperationsPerInvoke = 10000)]`
`19`	`19`	`public virtual void CreateAndDisposeUnusedContext()`
`20`	`20`	`{`
`21`	`21`	`for (var i = 0; i < 10000; i++)`
`@@ -27,7 +27,7 @@ public virtual void CreateAndDisposeUnusedContext()`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`		`- [Benchmark]`
	`30`	`+ [Benchmark(OperationsPerInvoke = 1000)]`
`31`	`31`	`public virtual void InitializeAndQuery_AdventureWorks()`
`32`	`32`	`{`
`33`	`33`	`for (var i = 0; i < 1000; i++)`
`@@ -39,7 +39,7 @@ public virtual void InitializeAndQuery_AdventureWorks()`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`- [Benchmark]`
	`42`	`+ [Benchmark(OperationsPerInvoke = 100)]`
`43`	`43`	`public virtual void InitializeAndSaveChanges_AdventureWorks()`
`44`	`44`	`{`
`45`	`45`	`for (var i = 0; i < 100; i++)`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,8 @@ public abstract class FuncletizationTests`
`16`	`16`	`{`
`17`	`17`	`private OrdersContextBase _context;`
`18`	`18`
`19`		`- protected virtual int FuncletizationIterationCount => 100;`
	`19`	`+ public const int OperationsPerInvoke = 100;`
	`20`	`+`
`20`	`21`	`protected abstract OrdersFixtureBase CreateFixture();`
`21`	`22`
`22`	`23`	`[GlobalSetup]`
`@@ -36,34 +37,34 @@ public virtual void CleanupContext()`
`36`	`37`	`_context.Dispose();`
`37`	`38`	`}`
`38`	`39`
`39`		`- [Benchmark]`
	`40`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`40`	`41`	`public virtual void NewQueryInstance()`
`41`	`42`	`{`
`42`	`43`	`var val = 11;`
`43`		`- for (var i = 0; i < FuncletizationIterationCount; i++)`
	`44`	`+ for (var i = 0; i < OperationsPerInvoke; i++)`
`44`	`45`	`{`
`45`	`46`	`_context.Products.Where(p => p.ProductId < val).ToList();`
`46`	`47`	`}`
`47`	`48`	`}`
`48`	`49`
`49`		`- [Benchmark]`
	`50`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`50`	`51`	`public virtual void SameQueryInstance()`
`51`	`52`	`{`
`52`	`53`	`var val = 11;`
`53`	`54`	`var query = _context.Products.Where(p => p.ProductId < val);`
`54`	`55`
`55`		`- for (var i = 0; i < FuncletizationIterationCount; i++)`
	`56`	`+ for (var i = 0; i < OperationsPerInvoke; i++)`
`56`	`57`	`{`
`57`	`58`	`// ReSharper disable once PossibleMultipleEnumeration`
`58`	`59`	`query.ToList();`
`59`	`60`	`}`
`60`	`61`	`}`
`61`	`62`
`62`		`- [Benchmark]`
	`63`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`63`	`64`	`public virtual void ValueFromObject()`
`64`	`65`	`{`
`65`	`66`	`var valueHolder = new ValueHolder();`
`66`		`- for (var i = 0; i < FuncletizationIterationCount; i++)`
	`67`	`+ for (var i = 0; i < OperationsPerInvoke; i++)`
`67`	`68`	`{`
`68`	`69`	`_context.Products.Where(p => p.ProductId < valueHolder.SecondLevelProperty).ToList();`
`69`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,8 +16,8 @@ public abstract class NavigationsQueryTests`
`16`	`16`	`private AdventureWorksContextBase _context;`
`17`	`17`	`private IQueryable<Store> _query;`
`18`	`18`
`19`		`- protected virtual int QueriesPerIteration => 10;`
`20`		`- protected virtual int UnfilteredCount => 466;`
	`19`	`+ public const int OperationsPerInvoke = 10;`
	`20`	`+ public const int UnfilteredCount = 466;`
`21`	`21`
`22`	`22`	`[Params(true, false)]`
`23`	`23`	`public bool Async { get; set; }`
`@@ -44,10 +44,10 @@ public virtual void CleanupContext()`
`44`	`44`	`_context.Dispose();`
`45`	`45`	`}`
`46`	`46`
`47`		`- [Benchmark]`
	`47`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`48`	`48`	`public virtual async Task PredicateAcrossOptionalNavigation()`
`49`	`49`	`{`
`50`		`- for (var i = 0; i < QueriesPerIteration; i++)`
	`50`	`+ for (var i = 0; i < OperationsPerInvoke; i++)`
`51`	`51`	`{`
`52`	`52`	`if (Async)`
`53`	`53`	`{`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,8 @@ namespace Microsoft.EntityFrameworkCore.Benchmarks.Query`
`19`	`19`	`[DisplayName(nameof(QueryCompilationTests))]`
`20`	`20`	`public abstract class QueryCompilationTests`
`21`	`21`	`{`
	`22`	`+ public const int OperationsPerInvoke = 10;`
	`23`	`+`
`22`	`24`	`private OrdersContextBase _context;`
`23`	`25`	`private IQueryable<Product> _simpleQuery;`
`24`	`26`	`private IQueryable<DTO> _complexQuery;`
`@@ -70,28 +72,28 @@ public virtual void CleanupContext()`
`70`	`72`	`_context.Dispose();`
`71`	`73`	`}`
`72`	`74`
`73`		`- [Benchmark]`
	`75`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`74`	`76`	`public virtual void ToList()`
`75`	`77`	`{`
`76`		`- for (var i = 0; i < 10; i++)`
	`78`	`+ for (var i = 0; i < OperationsPerInvoke; i++)`
`77`	`79`	`{`
`78`	`80`	`_simpleQuery.ToList();`
`79`	`81`	`}`
`80`	`82`	`}`
`81`	`83`
`82`		`- [Benchmark]`
	`84`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`83`	`85`	`public virtual void FilterOrderProject()`
`84`	`86`	`{`
`85`		`- for (var i = 0; i < 10; i++)`
	`87`	`+ for (var i = 0; i < OperationsPerInvoke; i++)`
`86`	`88`	`{`
`87`	`89`	`_complexQuery.ToList();`
`88`	`90`	`}`
`89`	`91`	`}`
`90`	`92`
`91`		`- [Benchmark]`
	`93`	`+ [Benchmark(OperationsPerInvoke = OperationsPerInvoke)]`
`92`	`94`	`public virtual void MultipleJoins()`
`93`	`95`	`{`
`94`		`- for (var i = 0; i < 10; i++)`
	`96`	`+ for (var i = 0; i < OperationsPerInvoke; i++)`
`95`	`97`	`{`
`96`	`98`	`_multipleJoinQuery.ToList();`
`97`	`99`	`}`