Improve performance of Contains (#174)

NetFabric · Jun 12, 2020 · f084eb4 · f084eb4
1 parent 250cf78
commit f084eb4
Show file tree

Hide file tree

Showing 67 changed files with 1,116 additions and 2,914 deletions.
diff --git a/NetFabric.Hyperlinq.Benchmarks/BenchmarksBase.cs b/NetFabric.Hyperlinq.Benchmarks/BenchmarksBase.cs
@@ -5,7 +5,7 @@
 
 namespace NetFabric.Hyperlinq.Benchmarks
 {
-    [SimpleJob(RuntimeMoniker.Net472, baseline: true)]
+    //[SimpleJob(RuntimeMoniker.Net472, baseline: true)]
     //[SimpleJob(RuntimeMoniker.NetCoreApp21)]
     [SimpleJob(RuntimeMoniker.NetCoreApp31)]
     //[SimpleJob(RuntimeMoniker.NetCoreApp50)]

diff --git a/NetFabric.Hyperlinq.Benchmarks/Contains.DefaultComparer.Benchmarks.cs b/NetFabric.Hyperlinq.Benchmarks/Contains.DefaultComparer.Benchmarks.cs
@@ -0,0 +1,111 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using JM.LinqFaster;
+using System;
+using System.Collections.Generic;
+
+namespace NetFabric.Hyperlinq.Benchmarks
+{
+    [GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+    [CategoriesColumn]
+    [MemoryDiagnoser]
+    [MarkdownExporterAttribute.GitHub]
+    public class ContainsDefaultComparerBenchmarks : BenchmarksBase
+    {
+        [BenchmarkCategory("Array")]
+        [Benchmark(Baseline = true)]
+        public bool Linq_Array() =>
+            System.Linq.Enumerable.Contains(array, Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Enumerable_Value")]
+        [Benchmark(Baseline = true)]
+        public bool Linq_Enumerable_Value() =>
+            System.Linq.Enumerable.Contains(enumerableValue, Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Collection_Value")]
+        [Benchmark(Baseline = true)]
+        public bool Linq_Collection_Value() =>
+            System.Linq.Enumerable.Contains(collectionValue, Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("List_Value")]
+        [Benchmark(Baseline = true)]
+        public bool Linq_List_Value() =>
+            System.Linq.Enumerable.Contains(listValue, Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Enumerable_Reference")]
+        [Benchmark(Baseline = true)]
+        public bool Linq_Enumerable_Reference() =>
+            System.Linq.Enumerable.Contains(enumerableReference, Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Collection_Reference")]
+        [Benchmark(Baseline = true)]
+        public bool Linq_Collection_Reference() =>
+            System.Linq.Enumerable.Contains(collectionReference, Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("List_Reference")]
+        [Benchmark(Baseline = true)]
+        public bool Linq_List_Reference() =>
+            System.Linq.Enumerable.Contains(listReference, Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Array")]
+        [Benchmark]
+        public bool LinqFaster_Array() =>
+            array.ContainsF(Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Array")]
+        [Benchmark]
+        public bool Hyperlinq_Array() =>
+            array.Contains(Count - 1, EqualityComparer<int>.Default);
+
+#if SPAN_SUPPORTED
+        [BenchmarkCategory("Array")]
+        [Benchmark]
+        public bool Hyperlinq_Span() =>
+            array.AsSpan().Contains(Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Array")]
+        [Benchmark]
+        public bool Hyperlinq_Memory() =>
+            memory.Contains(Count - 1, EqualityComparer<int>.Default);
+#endif
+
+        [BenchmarkCategory("Enumerable_Value")]
+        [Benchmark]
+        public bool Hyperlinq_Enumerable_Value() =>
+            Enumerable.AsValueEnumerable<TestEnumerable.Enumerable, TestEnumerable.Enumerable.Enumerator, int>(enumerableValue, enumerable => enumerable.GetEnumerator())
+            .Contains(Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Collection_Value")]
+        [Benchmark]
+        public bool Hyperlinq_Collection_Value() =>
+            ReadOnlyCollection.AsValueEnumerable<TestCollection.Enumerable, TestCollection.Enumerable.Enumerator, int>(collectionValue, enumerable => enumerable.GetEnumerator())
+            .Contains(Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("List_Value")]
+        [Benchmark]
+        public bool Hyperlinq_List_Value() =>
+            ReadOnlyList.AsValueEnumerable<int>(listValue)
+            .Contains(Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Enumerable_Reference")]
+        [Benchmark]
+        public bool Hyperlinq_Enumerable_Reference() =>
+            enumerableReference
+            .AsValueEnumerable()
+            .Contains(Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("Collection_Reference")]
+        [Benchmark]
+        public bool Hyperlinq_Collection_Reference() =>
+            collectionReference
+            .AsValueEnumerable()
+            .Contains(Count - 1, EqualityComparer<int>.Default);
+
+        [BenchmarkCategory("List_Reference")]
+        [Benchmark]
+        public bool Hyperlinq_List_Reference() =>
+            listReference
+            .AsValueEnumerable()
+            .Contains(Count - 1, EqualityComparer<int>.Default);
+    }
+}
diff --git a/NetFabric.Hyperlinq.Benchmarks/Program.cs b/NetFabric.Hyperlinq.Benchmarks/Program.cs
@@ -23,6 +23,7 @@ static void Main(string[] args)
                 typeof(AnyBenchmarks),
                 typeof(AnyPredicateBenchmarks),
                 typeof(ContainsBenchmarks),
+                typeof(ContainsDefaultComparerBenchmarks),
                 typeof(ContainsComparerBenchmarks),
                 typeof(DistinctBenchmarks),
                 typeof(ElementAtBenchmarks),

diff --git a/NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj b/NetFabric.Hyperlinq.UnitTests/NetFabric.Hyperlinq.UnitTests.csproj
@@ -47,9 +47,5 @@
   <ItemGroup>
     <DotNetCliToolReference Include="dotnet-reportgenerator-cli" Version="4.3.8" />
   </ItemGroup>
-
-  <ItemGroup>
-    <Folder Include="Generation\Return\" />
-  </ItemGroup>
 
 </Project>
diff --git a/NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.Array.Tests.cs b/NetFabric.Hyperlinq.UnitTests/Quantifier/Contains/Contains.Array.Tests.cs
@@ -46,7 +46,7 @@ public void Contains_With_Null_And_Contains_Must_ReturnTrue(int[] source)
         [MemberData(nameof(TestData.Empty), MemberType = typeof(TestData))]
         [MemberData(nameof(TestData.Single), MemberType = typeof(TestData))]
         [MemberData(nameof(TestData.Multiple), MemberType = typeof(TestData))]
-        public void Contains_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source)
+        public void Contains_With_DefaultComparer_And_NotContains_Must_ReturnFalse(int[] source)
         {
             // Arrange
             var value = int.MaxValue;
@@ -63,7 +63,7 @@ public void Contains_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source
         [Theory]
         [MemberData(nameof(TestData.Single), MemberType = typeof(TestData))]
         [MemberData(nameof(TestData.Multiple), MemberType = typeof(TestData))]
-        public void Contains_With_Comparer_And_Contains_Must_ReturnTrue(int[] source)
+        public void Contains_With_DefaultComparer_And_Contains_Must_ReturnTrue(int[] source)
         {
             // Arrange
             var value = System.Linq.Enumerable.Last(source);
@@ -76,5 +76,41 @@ public void Contains_With_Comparer_And_Contains_Must_ReturnTrue(int[] source)
             _ = result.Must()
                 .BeTrue();
         }
+
+
+        [Theory]
+        [MemberData(nameof(TestData.Empty), MemberType = typeof(TestData))]
+        [MemberData(nameof(TestData.Single), MemberType = typeof(TestData))]
+        [MemberData(nameof(TestData.Multiple), MemberType = typeof(TestData))]
+        public void Contains_With_Comparer_And_NotContains_Must_ReturnFalse(int[] source)
+        {
+            // Arrange
+            var value = int.MaxValue;
+
+            // Act
+            var result = Array
+                .Contains<int>(source, value, TestComparer<int>.Instance);
+
+            // Assert
+            _ = result.Must()
+                .BeFalse();
+        }
+
+        [Theory]
+        [MemberData(nameof(TestData.Single), MemberType = typeof(TestData))]
+        [MemberData(nameof(TestData.Multiple), MemberType = typeof(TestData))]
+        public void Contains_With_Comparer_And_Contains_Must_ReturnTrue(int[] source)
+        {
+            // Arrange
+            var value = System.Linq.Enumerable.Last(source);
+
+            // Act
+            var result = Array
+                .Contains<int>(source, value, TestComparer<int>.Instance);
+
+            // Assert
+            _ = result.Must()
+                .BeTrue();
+        }
     }
 }