SimpleSIMD 3.3.0

SimpleSIMD

What is SIMD?

Single Instruction, Multiple Data (SIMD) units refer to hardware components that perform the same operation on multiple data operands concurrently. The concurrency is performed on a single thread, while utilizing the full size of the processor register to perform several operations at one.
This approach could be combined with standard multithreading for massive performence boosts in numeric computations.

Goals And Purpose

• Single API to unify SIMD for All supported types
• Gain performence boost for mathematical computations using a simple API
• Simplifies SIMD usage, and to make it easy to integrate it into an already existing solutions
• Helps generalize several methemathical functions for supported types
• Performs less allocations compared to standard LINQ implementations

Available Functions

Comparison:

• Equal
• Greater
• GreaterOrEqual
• Less
• LessOrEqual

Elementwise:

• Negate
• Abs
• Add
• Divide
• Multiply
• Subtract
• And
• Or
• Xor
• Not
• Select
• Ternary (Conditional Select)
• Concat
• Sqrt

Reduction:

• Aggregate
• Sum
• Average
• Max
• Min
• Dot

General Purpose:

• All
• Any
• Contains
• IndexOf
• Fill
• Foreach

Auto-Generated Functions

For any of the Elementwise functions, an auto-generated overload is generated, which doesn't accept Span<T> result, and instead creates T[] internally and returns the result within this array.

For any of the functions with the Value Delagate pattern, an auto-generated overload is generated, which accepts regular delegates. Note that using this overload results in performence losses. Check Value Delegates - Benchmark section for more info.

Performance Benefits

A simple benchmark to demonstrate performance gains of using SIMD.
Benchmarked method was a Sum over an int[].

Value Delegates

This library extensively uses the value delegate pattern. This pattern is used as a replacement for delegates.
Calling functions using this patten may feel unusual since it requires creation of structs to pass as arguments instead of delegates, but it is very beneficial performance-wise. The performance difference makes using this pattern worthwhile in performance critical places.
Since the focus of this library is pure performance, we use this pattern wherever possible.

Wrap extension methods are included (SimpleSimd.Wrapper.Wrap(delegate)) to wrap regular delegates as Value Delegates.
Note that wrapping a regular delegate results in a performance hit - prefer using Value Delegates directly as shown below.

Usage:

using System;
using System.Numerics;
using SimpleSimd;

namespace MyProgram
{
    class Program
    {
        static void Main()
        {
            // Creating the data
            // Can be int[], Span<int>, ReadOnlySpan<int>
            int[] Data = GetData()
            
            // We need to create 2 structs which will serve as a replacement for delegates
            SimdOps<int>.Sum(Data, new VecSelector(), new Selector());
        }
    }             
    
    // A struct which is used as Vector<int> selector
    // Inheritence from IFunc is according to Sum() signature
    struct VecSelector : IFunc<Vector<int>, Vector<int>>
    {
        public Vector<int> Invoke(Vector<int> param) => param * 2;
    }

    // A struct which is used as int selector
    // Inheritence from IFunc is according to Sum() signature
    struct Selector : IFunc<int, int>
    {
        public int Invoke(int param) => param * 2;
    }   
}

benchmark:

Both of the benchmarked methods have the exactly same code, both of them are accelerated using SIMD,
the only difference is the argument types.

// Delegate, baseline
public static T Sum(Span<T> span, Func<Vector<T>, Vector<T>> vSelector, Func<T, T> selector)

// ValueDelegate
public static T Sum<F1, F2>(in Span<T> span, F1 vSelector, F2 selector)
            where F1 : struct, IFunc<Vector<T>, Vector<T>>
            where F2 : struct, IFunc<T, T> 

Limitations

• Methods are not lazily evaluated as IEnumerable
• Old hardware might not support SIMD
• Supported collection types:
  • T[] where T : unmanaged
  • Span<T> where T : unmanaged
  • ReadOnlySpan<T> where T : unmanaged
• Supports only Primitive Numeric Types as array elements. Supported types are:
  • byte, sbyte
  • short, ushort
  • int, uint
  • long, ulong
  • float
  • double

Contributing

All ideas and suggestions are welcome. Feel free to open an issue if you have an idea or a suggestion that might improve this project. If you encounter a bug or have a feature request, please open a relevent issue.

License

This project is licensed under MIT license. For more info see the License File