Improve All(predicate), Any(predicate) from array performance

Author: neuecc

sandbox/Benchmark/Benchmarks/AllAnyPredicateWithCapturedLambda.cs

@@ -0,0 +1,81 @@
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Configs;
+using ZLinq;
+
+namespace Benchmark;
+
+[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+public class AnyPredicateWithCapturedLambda
+{
+    [Params(10, 100, 1000, 10000)]
+    public int N;
+
+    int[] _nums = default!;
+    int _target;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _nums = Enumerable.Range(1, N).ToArray();
+        _target = N / 2;
+    }
+
+    [Benchmark]
+    [BenchmarkCategory("Array")]
+    public bool ArrayExists()
+    {
+        return Array.Exists(_nums, i => i > _target);
+    }
+
+    [Benchmark]
+    [BenchmarkCategory(Categories.ZLinq)]
+    public bool ZLinq()
+    {
+        return _nums.AsValueEnumerable().Any(i => i > _target);
+    }
+
+    [Benchmark]
+    [BenchmarkCategory(Categories.LINQ)]
+    public bool Linq()
+    {
+        return _nums.Any(i => i > _target);
+    }
+}
+
+[GroupBenchmarksBy(BenchmarkLogicalGroupRule.ByCategory)]
+public class AllPredicateWithCapturedLambda
+{
+    [Params(10, 100, 1000, 10000)]
+    public int N;
+
+    int[] _nums = default!;
+    int _target;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        _nums = Enumerable.Range(1, N).ToArray();
+        _target = N;
+    }
+
+    [Benchmark]
+    [BenchmarkCategory("Array")]
+    public bool TrueForAll()
+    {
+        return Array.TrueForAll(_nums, i => i <= _target);
+    }
+
+    [Benchmark]
+    [BenchmarkCategory(Categories.ZLinq)]
+    public bool ZLinq()
+    {
+        return _nums.AsValueEnumerable().All(i => i <= _target);
+    }
+
+    [Benchmark]
+    [BenchmarkCategory(Categories.LINQ)]
+    public bool Linq()
+    {
+        return _nums.All(i => i <= _target);
+    }
+}

sandbox/Benchmark/Program.cs

@@ -22,8 +22,13 @@ internal static class Program
     public static int Main(string[] args)
     {
 #if DEBUG
-        var bench = new Benchmark.SelectFromEnumerableArray();
-        bench.ZLinqSelect_FromIReadOnlyListArray();
+        var bench = new Benchmark.AnyPredicate();
+        bench.N = 1000;
+        bench.Setup();
+
+        bench.ArrayExists();
+        bench.Linq();
+        bench.ZLinq();
 
 
         return 0;

sandbox/Benchmark/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "Default": {
       "commandName": "Project",
-      "commandLineArgs": "--filter Benchmark.LinqPerfBenchmarks.Count00* -- Default",
+      "commandLineArgs": "--filter Benchmark.AllPredicateWithCapturedLambda* -- Default",
 
       // Available config
       // 1. Default
@@ -64,6 +64,7 @@
       // "commandLineArgs": "--filter Benchmark.SimdCount.*",
       // "commandLineArgs": "--filter Benchmark.Net80OptimizedBenchmark.*",
       // "commandLineArgs": "--filter Benchmark.Net90OptimizedBenchmark.*",
+      // "commandLineArgs": "--filter Benchmark.AnyPredicate* -- Default",
       "workingDirectory": "."
     },
     "Select Benchmark": {

src/ZLinq/Linq/All.cs

@@ -36,5 +36,41 @@ public static Boolean All<TEnumerator, TSource>(this ValueEnumerable<TEnumerator
                 return true;
             }
         }
+
+        public static Boolean All<TSource>(this ValueEnumerable<FromArray<TSource>, TSource> source, Func<TSource, Boolean> predicate)
+        {
+            ArgumentNullException.ThrowIfNull(predicate);
+
+            var array = source.Enumerator.GetSource();
+            if (array.GetType() != typeof(TSource[]))
+            {
+                return All(array, predicate);
+            }
+
+            // The assembly output differs slightly when iterating through array and span.
+            // According to microbenckmark results, iterating through span was faster for the logic passed to predicate.
+            var span = (ReadOnlySpan<TSource>)array;
+            for (int i = 0; i < span.Length; i++)
+            {
+                if (!predicate(span[i]))
+                {
+                    return false;
+                }
+            }
+            return true;
+
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            static Boolean All(TSource[] array, Func<TSource, Boolean> predicate)
+            {
+                for (int i = 0; i < array.Length; i++)
+                {
+                    if (!predicate(array[i]))
+                    {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
     }
 }

src/ZLinq/Linq/Any.cs

@@ -1,4 +1,6 @@
-namespace ZLinq
+using System;
+
+namespace ZLinq
 {
     partial class ValueEnumerableExtensions
     {
@@ -53,5 +55,43 @@ public static Boolean Any<TEnumerator, TSource>(this ValueEnumerable<TEnumerator
                 return false;
             }
         }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Boolean Any<TSource>(this ValueEnumerable<FromArray<TSource>, TSource> source, Func<TSource, Boolean> predicate)
+        {
+            ArgumentNullException.ThrowIfNull(predicate);
+
+            var array = source.Enumerator.GetSource();
+            if (array.GetType() != typeof(TSource[]))
+            {
+                return Any(array, predicate);
+            }
+
+            // The assembly output differs slightly when iterating through array and span.
+            // According to microbenckmark results, iterating through span was faster for the logic passed to predicate.
+            var span = (ReadOnlySpan<TSource>)array;
+            for (int i = 0; i < span.Length; i++)
+            {
+                if (predicate(span[i]))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+
+            [MethodImpl(MethodImplOptions.NoInlining)]
+            static Boolean Any(TSource[] array, Func<TSource, Boolean> predicate)
+            {
+                for (int i = 0; i < array.Length; i++)
+                {
+                    if (predicate(array[i]))
+                    {
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
     }
 }

src/ZLinq/Linq/AsValueEnumerable.cs

@@ -368,6 +368,7 @@ public struct FromArray<T>(T[] source) : IValueEnumerator<T>
         int index;
 
         // becareful, don't call AsSpan
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal T[] GetSource() => source;
 
         public bool TryGetNonEnumeratedCount(out int count)
@@ -379,7 +380,7 @@ public bool TryGetNonEnumeratedCount(out int count)
         public bool TryGetSpan(out ReadOnlySpan<T> span)
         {
             // AsSpan is failed by array variance
-            if (!typeof(T).IsValueType && source.GetType() != typeof(T[]))
+            if (source.GetType() != typeof(T[]))
             {
                 span = default;
                 return false;
@@ -489,6 +490,7 @@ public struct FromList<T>(List<T> source) : IValueEnumerator<T>
     {
         int index;
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal List<T> GetSource() => source;
 
         public bool TryGetNonEnumeratedCount(out int count)