space-wizards/RobustToolbox
1
0
Fork 0
mirror of https://github.com/space-wizards/RobustToolbox.git synced 2026-02-15 03:30:53 +01:00
Code Issues Packages Projects Releases Wiki Activity

Reorganizes NumericsHelpers into different files using partial classes. (#1514)

Browse Source
This commit is contained in:
Vera Aguilera Puerto
2021-01-29 12:46:27 +01:00
committed by GitHub
parent fc5e3ab69d
commit dbe9a96dfa
8 changed files with 2054 additions and 1976 deletions
Download Patch File Download Diff File Expand all files Collapse all files

295
Robust.Shared.Maths/NumericsHelpers.Multiply.cs Normal file
View File

@@ -0,0 +1,295 @@
using System;
using System.Runtime.CompilerServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.Arm;
using System.Runtime.Intrinsics.X86;
namespace Robust.Shared.Maths
{
public static unsafe partial class NumericsHelpers
{
#region Multiply
/// <summary>
/// Multiplies a by b and stores the result in a.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public static void Multiply(Span<float> a, ReadOnlySpan<float> b)
{
Multiply(a, b, a);
}
/// <summary>
/// Multiplies a by b and stores the result in s.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public static void Multiply(ReadOnlySpan<float> a, ReadOnlySpan<float> b, Span<float> s)
{
if (a.Length != b.Length || a.Length != s.Length)
throw new ArgumentException("Length of arrays must be the same!");
if (Enabled)
{
if (AvxEnabled && LengthValid256Single(a.Length))
{
MultiplyAvx(a, b, s);
return;
}
if (LengthValid128Single(a.Length))
{
if (Sse.IsSupported)
{
MultiplySse(a, b, s);
return;
}
if (AdvSimd.IsSupported)
{
MultiplyAdvSimd(a, b, s);
return;
}
}
}
MultiplyNaive(a, b, s, 0, a.Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplyNaive(ReadOnlySpan<float> a, ReadOnlySpan<float> b, Span<float> s, int start, int end)
{
for (var i = start; i < end; i++)
{
s[i] = a[i] * b[i];
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplySse(ReadOnlySpan<float> a, ReadOnlySpan<float> b, Span<float> s)
{
var remainder = a.Length & 3;
var length = a.Length - remainder;
fixed (float* ptr = a)
{
fixed (float* ptrB = b)
{
fixed (float* ptrS = s)
{
for (var i = 0; i < length; i += 4)
{
var j = Sse.LoadVector128(ptr + i);
var k = Sse.LoadVector128(ptrB + i);
Sse.Store(ptrS + i, Sse.Multiply(j, k));
}
}
}
}
if(remainder != 0)
{
MultiplyNaive(a, b, s, length, a.Length);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplyAdvSimd(ReadOnlySpan<float> a, ReadOnlySpan<float> b, Span<float> s)
{
var remainder = a.Length & 3;
var length = a.Length - remainder;
fixed (float* ptr = a)
{
fixed (float* ptrB = b)
{
fixed (float* ptrS = s)
{
for (var i = 0; i < length; i += 4)
{
var j = AdvSimd.LoadVector128(ptr + i);
var k = AdvSimd.LoadVector128(ptrB + i);
AdvSimd.Store(ptrS + i, AdvSimd.Multiply(j, k));
}
}
}
}
if(remainder != 0)
{
MultiplyNaive(a, b, s, length, a.Length);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplyAvx(ReadOnlySpan<float> a, ReadOnlySpan<float> b, Span<float> s)
{
var remainder = a.Length & 7;
var length = a.Length - remainder;
fixed (float* ptr = a)
{
fixed (float* ptrB = b)
{
fixed (float* ptrS = s)
{
for (var i = 0; i < length; i += 8)
{
var j = Avx.LoadVector256(ptr + i);
var k = Avx.LoadVector256(ptrB + i);
Avx.Store(ptrS + i, Avx.Multiply(j, k));
}
}
}
}
if(remainder != 0)
{
MultiplyNaive(a, b, s, length, a.Length);
}
}
#endregion
#region MultiplyByScalar
/// <summary>
/// Multiply a by scalar b and stores the result in a.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public static void Multiply(Span<float> a, float b)
{
Multiply(a, b, a);
}
/// <summary>
/// Multiply a by scalar b and stores the result in s.
/// </summary>
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
public static void Multiply(ReadOnlySpan<float> a, float b, Span<float> s)
{
if (a.Length != s.Length)
throw new ArgumentException("Length of arrays must be the same!");
if (Enabled)
{
if (AvxEnabled && LengthValid256Single(a.Length))
{
MultiplyAvx(a, b, s);
return;
}
if (LengthValid128Single(a.Length))
{
if (Sse.IsSupported)
{
MultiplySse(a, b, s);
return;
}
if (AdvSimd.IsSupported)
{
MultiplyAdvSimd(a, b, s);
return;
}
}
}
MultiplyNaive(a, b, s, 0, a.Length);
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplyNaive(ReadOnlySpan<float> a, float b, Span<float> s, int start, int end)
{
for (var i = start; i < end; i++)
{
s[i] = a[i] * b;
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplySse(ReadOnlySpan<float> a, float b, Span<float> s)
{
var remainder = a.Length & 3;
var length = a.Length - remainder;
var scalar = Vector128.Create(b);
fixed (float* ptr = a)
{
fixed (float* ptrS = s)
{
for (var i = 0; i < length; i += 4)
{
var j = Sse.LoadVector128(ptr + i);
Sse.Store(ptrS + i, Sse.Multiply(j, scalar));
}
}
}
if(remainder != 0)
{
MultiplyNaive(a, b, s, length, a.Length);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplyAdvSimd(ReadOnlySpan<float> a, float b, Span<float> s)
{
var remainder = a.Length & 3;
var length = a.Length - remainder;
var scalar = Vector128.Create(b);
fixed (float* ptr = a)
{
fixed (float* ptrS = s)
{
for (var i = 0; i < length; i += 4)
{
var j = AdvSimd.LoadVector128(ptr + i);
AdvSimd.Store(ptrS + i, AdvSimd.Multiply(j, scalar));
}
}
}
if(remainder != 0)
{
MultiplyNaive(a, b, s, length, a.Length);
}
}
[MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
private static void MultiplyAvx(ReadOnlySpan<float> a, float b, Span<float> s)
{
var remainder = a.Length & 7;
var length = a.Length - remainder;
var scalar = Vector256.Create(b);
fixed (float* ptr = a)
{
fixed (float* ptrS = s)
{
for (var i = 0; i < length; i += 8)
{
var j = Avx.LoadVector256(ptr + i);
Avx.Store(ptrS + i, Avx.Multiply(j, scalar));
}
}
}
if(remainder != 0)
{
MultiplyNaive(a, b, s, length, a.Length);
}
}
#endregion
}
}