IntrinsicsPlayground

My toys to play with intrinsics in pure C# (see System.Runtime.Intrinsics.Experimental)

Environment:

BenchmarkDotNet=v0.10.14, OS=Windows 10.0.17134
Intel Core i7-8700K CPU 3.70GHz (Coffee Lake), 1 CPU, 12 logical and 6 physical cores
Frequency=3609374 Hz, Resolution=277.0564 ns, Timer=TSC
.NET Core SDK=2.1.301
  [Host]     : .NET Core 2.1.1 (CoreCLR 4.6.26606.02, CoreFX 4.6.26606.05), 64bit RyuJIT
  DefaultJob : .NET Core 2.1.1 (CoreCLR 4.6.26606.02, CoreFX 4.6.26606.05), 64bit RyuJIT

1. ArraySum

Sum of elements in an array of floats

var sum = arrayOfFloats.Sum();

| Method | TestArrayLength | Mean | Scaled | |-------------------|-----------------|-------------------:|----------:| | Sum_LINQ | 10 | 45.629 ns | 4.81 | | Sum_Simple | 10 | 2.879 ns | 0.30 | | Sum_LinqFasterLib | 10 | 15.100 ns | 1.59 | | Sum_Avx | 10 | 9.496 ns | 1.00 | | | | | | | Sum_LINQ | 121 | 439.021 ns | 25.20 | | Sum_Simple | 121 | 78.111 ns | 4.48 | | Sum_LinqFasterLib | 121 | 22.432 ns | 1.29 | | Sum_Avx | 121 | 17.423 ns | 1.00 | | | | | | | Sum_LINQ | 32768 | 109,128.390 ns | 31.87 | | Sum_Simple | 32768 | 27,345.722 ns | 7.99 | | Sum_LinqFasterLib | 32768 | 3,432.010 ns | 1.00 | | Sum_Avx | 32768 | 3,423.826 ns | 1.00 |

2. ArrayEqual

Are arrays of floats equal?

var equal = arrayOfFloats1.SequenceEqual(arrayOfFloats2);

| Method | TestArrayLength | Mean | Scaled | |-----------------------|-----------------|-------------------:|----------:| | ArrayEqual_LINQ | 10 | 116.175 ns | 30.22 | | ArrayEqual_Simple | 10 | 6.130 ns | 1.59 | | ArrayEqual_AVX2 | 10 | 3.845 ns | 1.00 | | | | | | | ArrayEqual_LINQ | 121 | 783.744 ns | 50.82 | | ArrayEqual_Simple | 121 | 60.981 ns | 3.95 | | ArrayEqual_AVX2 | 121 | 15.425 ns | 1.00 | | | | | | | ArrayEqual_LINQ | 32768 | 198,072.829 ns | 52.85 | | ArrayEqual_Simple | 32768 | 13,773.698 ns | 3.67 | | ArrayEqual_AVX2 | 32768 | 3,748.025 ns | 1.00 |

3. ArrayMax

Max element in an array of ints

var max = arrayOfInts.Max();

| Method | TestArrayLength | Mean | Scaled | |-------------------|-----------------|-------------------:|----------:| | Max_LINQ | 10 | 44.932 ns | 3.38 | | Max_Simple | 10 | 3.125 ns | 0.23 | | Max_LinqFasterLib | 10 | 14.071 ns | 1.06 | | Max_Avx | 10 | 13.307 ns | 1.00 | | | | | | | Max_LINQ | 121 | 447.998 ns | 23.34 | | Max_Simple | 121 | 42.731 ns | 2.23 | | Max_LinqFasterLib | 121 | 19.230 ns | 1.00 | | Max_Avx | 121 | 19.219 ns | 1.00 | | | | | | | Max_LINQ | 32768 | 116,163.414 ns | 69.46 | | Max_Simple | 32768 | 10,300.011 ns | 6.16 | | Max_LinqFasterLib | 32768 | 1,759.705 ns | 1.05 | | Max_Avx | 32768 | 1,672.383 ns | 1.00 |

4. ArrayIsSorted

Check if an array is sorted or not

bool IsSorted(int[] array)
{
    if (array.Length < 2)
        return true;

    for (int i = 0; i < array.Length - 1; i++)
    {
        if (array[i] > array[i + 1])
            return false;
    }
    return true;
}

| Method | TestArrayLength | Mean | Scaled | |---------------------------|-----------------|------------------:|---------:| | IsSorted_Simple | 10 | 6.309 ns | 2.51 | | IsSorted_Simple_Optimized | 10 | 4.784 ns | 1.90 | | IsSorted_Sse41 | 10 | 2.691 ns | 1.07 | | IsSorted_Avx2 | 10 | 2.513 ns | 1.00 | | | | | | | IsSorted_Simple | 121 | 80.036 ns | 6.38 | | IsSorted_Simple_Optimized | 121 | 54.508 ns | 4.35 | | IsSorted_Sse41 | 121 | 22.927 ns | 1.83 | | IsSorted_Avx2 | 121 | 12.539 ns | 1.00 | | | | | | | IsSorted_Simple | 32768 | 19,928.318 ns | 5.31 | | IsSorted_Simple_Optimized | 32768 | 13,705.714 ns | 3.65 | | IsSorted_Sse41 | 32768 | 6,190.854 ns | 1.65 | | IsSorted_Avx2 | 32768 | 3,755.430 ns | 1.00 |

5. ArrayReverse

Reverse all elements in an array

Array.Reverse(arrayOfInts);

| Method | TestArrayLength | Mean | Scaled | |-----------------|-----------------|-----------------:|---------:| | Reverse_BCL | 10 | 46.72 ns | 0.96 | | Reverse_SSE | 10 | 48.70 ns | 1.00 | | | | | | | Reverse_BCL | 121 | 102.90 ns | 1.27 | | Reverse_SSE | 121 | 80.82 ns | 1.00 | | | | | | | Reverse_BCL | 32768 | 18,083.44 ns | 1.56 | | Reverse_SSE | 32768 | 11,577.33 ns | 1.00 |

6. ArrayIndexOf

Searche for the specified element and returns the index of its first occurrence

int index = Array.IndexOf(arrayOfInts, element);

| Method | TestArrayLength | Mean | Scaled | |-----------------|---------------- |-----------------:|---------:| | IndexOf_BCL | 10 | 7.701 ns | 1.37 | | IndexOf_Avx2 | 10 | 5.620 ns | 1.00 | | | | | | | IndexOf_BCL | 121 | 31.721 ns | 3.59 | | IndexOf_Avx2 | 121 | 8.825 ns | 1.00 | | | | | | | IndexOf_BCL | 32768 | 6,961.574 ns | 3.72 | | IndexOf_Avx2 | 32768 | 1,870.329 ns | 1.00 |

7. MatrixSum

Add two matrices (Matrix4x4)

var matrix3 = matrix1 + matrix2;

| Method | Mean | Scaled | |-------------- |---------:|-------:| | MatrixSum_BCL | 25.81 us | 1.30 | | MatrixSum_Avx | 19.89 us | 1.00 |

8. MatrixNegate

Negate a matrix (Matrix4x4)

matrix = -matrix;

| Method | Mean | Scaled | |----------------- |---------:|-------:| | MatrixNegate_BCL | 34.31 us | 1.38 | | MatrixNegate_Avx | 24.87 us | 1.00 |

9. MatrixMultiply

Multiply a matrix by a vector

matrix = matrix * vec;

| Method | Mean | Scaled | |---------------------------- |---------:|-------:| | MatrixMultiply_ByVector_BCL | 28.01 us | 1.04 | | MatrixMultiply_ByVector_Avx | 26.83 us | 1.00 |

Misc

1. Array.Sort vs DualPivotQuickSort

Dual pivot quick sort is used in Java for primitive types (Arrays.sort(int[])).