Awesome

SIMDArray FSharp

SIMD and other Performance enhanced Array operations for F#

Example Usage

//Faster map

let array = [| 1 .. 1000 |]
let squaredArray = array |> Array.SIMD.map (fun x -> x*x) (fun x -> x*x)  

// Map and many other functions need one lambda to map the Vector<T>, 
// and one to handle any leftover elements if array is not divisible by 
// Vector<T>.Count. In the case of simple arithmetic operations they can
// often be the same as shown here. If you arrange your arrays such that 
// they will never have leftovers, or don't care how leftovers are treated 
// just pass a nop like so:

open SIMDArrayUtils

let array = [|1;2;3;4;5;6;7;8|]
let squaredArray = array |> Array.SIMD.map (fun x -> x*x) nop


// Some functions can be used just like the existing array functions but run faster
// such as create and sum:

let newArray = Array.SIMD.create 1000 5 //create a new array of length 1000 filled with 5
let sum = Array.SIMD.sum newArray

// The Performance module has functions that are faster and/or use less memory
// via other means than SIMD. Usually by relaxing ordering constraints or adding
// constraints to predicates:

let distinctElements = Array.Performance.distinctUnordered someArray
let filteredElements = Array.Performance.filterLessThan 5 someArray
let filteredElements = Array.Performance.filterSimplePredicate (fun x -> x*x < 100) someArray
Array.Performance.mapInPlace (fun x-> x*x) someArray

// The SIMDParallel module has parallelized versions of some of the SIMD operations:

let sum = Array.SIMDParallel.sum array
let map = Array.SIMDParallel.map (fun x -> x*x) array

// Two extensions are added to System.Threading.Tasks.Parallel, to enable Parallel.For loops
// with a stride length efficiently. They also have much less overhead. You can use them to roll your own 
// parallel SIMD functions, or any parallel operation that needs a stride length > 1

// Using:
// ForStride (fromInclusive : int) (toExclusive :int) (stride : int) (f : int -> unit)
// You can map each Vector in an array and store it in result
Parallel.ForStride 0 array.Length (Vector< ^T>.Count) 
        (fun i -> (vf (Vector< ^T>(array,i ))).CopyTo(result,i))

// Using:
// ForStrideAggreagate (fromInclusive : int) (toExclusive :int) (stride : int) (acc: ^T) (f : int -> ^T -> ^T) combiner
// You can sum or otherwise aggregate the elements of an array a Vector at a time, starting from an initial acc
let result = Parallel.ForStrideAggreagate 0 array.Length (Vector< ^T>.Count) Vector< ^T>(0)
					(fun i acc -> acc + (Vector< ^T>(array,i)))  
					(fun x acc -> x + acc)  //combines the results from each task into a final Vector that is returned

Notes

Only 64 bit builds are supported. Mono should work with 5.0+, but I have not yet tested it. Performance improvements will vary depending on your CPU architecture, width of Vector type, and the operations you apply. For small arrays the core libs may be faster due SIMD overhead. When measuring performance be sure to use Release builds with optimizations turned on.

Floating point addition is not associative, so results with SIMD operations will not be identical, though often they will be more accurate, such as in the case of sum, or average.

Upd: .NET 7.0 Basic Tests

// * Summary *

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19044.1526 (21H2)
AMD Ryzen 7 3800X, 1 CPU, 16 logical and 8 physical cores
.NET SDK=7.0.100-preview.3.22179.4
  [Host]     : .NET 7.0.0 (7.0.22.17504), X64 RyuJIT DEBUG
  DefaultJob : .NET 7.0.0 (7.0.22.17504), X64 RyuJIT


|     Method |  Length |            Mean |         Error |        StdDev |   Gen 0 |   Gen 1 |   Gen 2 |   Allocated |
|----------- |-------- |----------------:|--------------:|--------------:|--------:|--------:|--------:|------------:|
|     ForSum |     100 |        98.78 ns |      0.533 ns |      0.473 ns |  0.0507 |       - |       - |       424 B |
| ForSumSIMD |     100 |        56.32 ns |      0.378 ns |      0.353 ns |  0.0507 |  0.0001 |       - |       424 B |
|        Dot |     100 |       157.32 ns |      0.672 ns |      0.629 ns |       - |       - |       - |           - |
|    DotSIMD |     100 |        19.59 ns |      0.121 ns |      0.107 ns |       - |       - |       - |           - |
|        Max |     100 |        55.57 ns |      0.146 ns |      0.129 ns |       - |       - |       - |           - |
|    MaxSIMD |     100 |        13.53 ns |      0.070 ns |      0.065 ns |       - |       - |       - |           - |
|      MaxBy |     100 |        60.37 ns |      0.163 ns |      0.153 ns |       - |       - |       - |           - |
|  MaxBySIMD |     100 |        20.06 ns |      0.063 ns |      0.056 ns |       - |       - |       - |           - |
|     ForSum |    1000 |       862.28 ns |      5.412 ns |      5.063 ns |  0.4807 |  0.0067 |       - |     4,024 B |
| ForSumSIMD |    1000 |       441.22 ns |      2.874 ns |      2.548 ns |  0.4809 |  0.0072 |       - |     4,024 B |
|        Dot |    1000 |     1,484.23 ns |      5.292 ns |      4.691 ns |       - |       - |       - |           - |
|    DotSIMD |    1000 |       162.66 ns |      1.095 ns |      0.971 ns |       - |       - |       - |           - |
|        Max |    1000 |       526.03 ns |      2.177 ns |      1.818 ns |       - |       - |       - |           - |
|    MaxSIMD |    1000 |        44.45 ns |      0.101 ns |      0.094 ns |       - |       - |       - |           - |
|      MaxBy |    1000 |       506.51 ns |      0.619 ns |      0.548 ns |       - |       - |       - |           - |
|  MaxBySIMD |    1000 |       139.48 ns |      0.126 ns |      0.106 ns |       - |       - |       - |           - |
|     ForSum | 1000000 | 1,642,884.15 ns | 32,686.799 ns | 52,783.087 ns | 93.7500 | 93.7500 | 93.7500 | 4,000,061 B |
| ForSumSIMD | 1000000 |   484,576.66 ns |  9,685.048 ns |  9,512.012 ns | 95.7031 | 95.7031 | 95.7031 | 4,000,055 B |
|        Dot | 1000000 | 1,468,907.49 ns |  6,495.111 ns |  5,070.956 ns |       - |       - |       - |           - |
|    DotSIMD | 1000000 |   160,549.66 ns |    277.915 ns |    232.071 ns |       - |       - |       - |           - |
|        Max | 1000000 |   485,969.64 ns |    565.230 ns |    501.061 ns |       - |       - |       - |           - |
|    MaxSIMD | 1000000 |    48,748.71 ns |     72.373 ns |     67.698 ns |       - |       - |       - |           - |
|      MaxBy | 1000000 |   490,922.69 ns |    563.828 ns |    470.822 ns |       - |       - |       - |           - |
|  MaxBySIMD | 1000000 |   135,049.15 ns |     57.546 ns |     51.013 ns |       - |       - |       - |           - |

Performance Comparison vs Standard Array Functions

• VS Core Lib Parallel
• VS Core Lib 32bit Floats
• VS Core Lib 64bit Floats
• VS MathNET.Numerics 32bit Floats
• VS MathNET.Numerics MKL Native 32bit Floats

Host Process Environment Information:
BenchmarkDotNet=v0.9.8.0
OS=Microsoft Windows NT 6.2.9200.0
Processor=Intel(R) Core(TM) i7-4712HQ CPU 2.30GHz, ProcessorCount=8
Frequency=2240907 ticks, Resolution=446.2479 ns, Timer=TSC
CLR=MS.NET 4.0.30319.42000, Arch=64-bit RELEASE [RyuJIT]
GC=Concurrent Workstation
JitModules=clrjit-v4.6.1590.0

Type=SIMDBenchmark  Mode=Throughput  Platform=X64  
Jit=RyuJit  GarbageCollection=Concurrent Workstation  

Sum 1 million 32bit ints, ParallelSIMD vs SIMD vs Core Lib <a name="parallel"></a>

With 32bit Floats Vs Core Lib. Map function (fun x -> x*x)<a name="core32"></a>

With 64bit Floats vs Core Lib. Map function (fun x -> x*x+x)<a name="core64"></a>

With 32bit Floats vs MathNET.Numerics managed. Map function (fun x -> x*x+x) <a name="mathnet"></a>

With 32bit Floats vs MathNET.Numerics MKL Native. Adding two arrays <a name="mathnetnative"></a>