SIMD Math tracking issue

[WhiteBlackGoose]

COMMUNITY-DRIVEN WORK TRACKING ISSUE

Tracks implementation of the SIMD Math Proposal.

It is being implemented in the feature/math-simd.

Tasks

API implementation

665 (generator)

• [x] Create
• [x] Load
• [x] Add
• [x] Subtract
• [x] Multiply
• [x] Divide
• [x] Abs
• [x] Constants
• [x] And
• [x] Or
• [x] Xor
• [x] Not
• [x] AllBitsSet
• [x] IsHardwareAccelerated

670

• [x] Equal
• [x] NotEqual
• [x] GreaterThan
• [x] GreaterOrEqual
• [x] LessThan
• [x] LessThanOrEqual
• [x] Min
• [x] Max

684

• [x] IsFinite
• [x] IsInfinity
• [x] IsNaN
• [x] IsNegative
• [x] IsNegativeInfinity
• [x] IsNormal
• [x] IsPositiveInfinity
• [x] Sign

Arithmetics

• [ ] Negate

Special

• [ ] As
• [ ] IEEERemainder

Trigonometry

• [ ] Acos
• [ ] Acosh
• [ ] Asin
• [ ] Asinh
• [ ] Atan2
• [ ] Atan
• [ ] Atanh
• [ ] Cos
• [ ] Cosh
• [ ] Sin
• [ ] Sinh
• [ ] Tan
• [ ] Tanh

Powers

• [ ] Exp
• [ ] Cbrt
• [ ] Sqrt
• [ ] Pow
• [ ] Log10
• [ ] Log
• [ ] Log of two args
• [ ] Reciprocal

Rounding

• [ ] Floor
• [ ] Ceiling
• [ ] Round
• [ ] Round of two args
• [ ] Truncate

Bit operations

• [ ] ShiftLeft
• [ ] ShiftRight
• [ ] RotateLeft
• [ ] RotateRight

Tests

For all bitnesses x for all types

670

• [x] 4 arithmetic operators
• [x] Less/Greater Than (OrEqual)
• [x] Min, Max
• [x] (Not)Equal
• [x] Bitwise operations

684

• [x] State of number

Other

• [ ] Create, Load, Store
• [ ] Regular trigonometry
• [ ] Hyperbolic trigonometry
• [ ] Inverse trigonometry
• [ ] Inverse hyperbolic trigonometry
• [ ] Power
• [ ] Rounding
• [ ] Bit operations

Benchmarks

For all bitnesses x for all types

670

• [x] 4 arithmetic operators
• [x] Less/Greater Than (OrEqual)
• [x] Min, Max
• [x] (Not)Equal

684

• [x] State of number
• [x] Bitwise operations
• [x] Abs

Other

• [ ] Create, Load, Store
• [ ] Regular trigonometry
• [ ] Hyperbolic trigonometry
• [ ] Inverse trigonometry
• [ ] Inverse hyperbolic trigonometry
• [ ] Power
• [ ] Rounding
• [ ] Bit operations

TODOs

670

• [x] Make fallback to 128-bit if 256-bit is not supported
• [x] Use naive operations for 8-byte values on simd64

684

• [x] The random feeder should be either static or without seed or anything, otherwise it fills both vectors with the same data

Other

• [ ] Divide for integers to be done in a more efficient way link
• [ ] Multiply for bytes to be done in a more efficient way link
• [ ] Use intrinsic ShiftRight/ShiftLeft once proposal is impl
• [ ] Remove unmanaged constraints where possible
• [ ] Relax constraints to struct where possible
• [ ] Hardware accelerated comparison operations for long and ulong

Far TODOs

• [ ] Propose & add support for Simd512 (that requires runtime support)

To discuss

678

• [x] AllBitsSet API for Scalar

690

Other

• [ ] MaxValueOver2 API for Simd and Scalar
• [ ] IsHardwareAccelerated should be && IsSupported? Otherwise Simd128<MyAwesomeType>.IsHardwareAccelerated returns true on net5 on avx machine
• [ ] Math.Abs throws on Math.Abs(int.MinValue). We can keep it, or we can have a faster version without this check
• [ ] CopySign API

[WhiteBlackGoose]

Ideas

Sinh / Cosh

Those two have similar formulas:

(e^x + e^-x) / 2
(e^x - e^-x) / 2

So we can have Sinh/Cosh method

Speaking of implementation, we have

var ex = Simd.Exp(x);
var exm = Simd.Reciprocal(ex);
var multiplier = Simd.Create(0.5);
var sinh = Simd.Multiply(Simd.Subtract(ex, exm), multiplier);
var cosh = Simd.Multiply(Simd.Add(ex, exm), multiplier);
return (sinh, cosh);

Exp

• AMD's expf (fast impl of exp for regular cast in C)
• AMD's simd exp (that's what we need but in asm)
• Simd exp from SO

Min/Max for longs

var compared = LessThan(left, right);
var antiCompared = GreaterThanOrEqual(left, right);
var withOnes = And(compared, Vector.Create(1));
var antiWithOnes = And(compared, Vector.Create(1));
var res = Or(Multiply(withOnes, left), Multiply(antiWithOnes, right));

State of number

1. IsPositiveInfinity and IsNegativeInfinity can be verified on exact equality (for ints it returns zero) (though Tanner mentions some exception)
2. IsFinite is & and equality: source (for ints it returns all bits set)
3. IsInfinity is trivial too (for ints it returns zero)
4. NaN can be checked with inequality to itself
5. IsNegative/IsPositive should probably be Compare Less/Greater against 0? Or source
6. IsNormal just follows source

[HurricanKai]

Should verify that for Store (and other void returning methods) the nested method trick actually works.

[WhiteBlackGoose]

128 bit sharplab

256 bit sharplab

64 bit sharplab (well I don't have a mobile sharplab)

@HurricanKai

And also it's probably #665 -related, not this issue

[HurricanKai]

Future: Look at checking for IsHardwareAccelerated before calling down into other methods, don't want to ie call Not(LessThen(...)) if it's not hardware accelerated, because it means two loops with non-hardware accelerated Loads/Stores

[HurricanKai]

Future: Improve IsNegative check by checking for bit instead of doing a full blown compare

[WhiteBlackGoose]

Important: Notes from working group meeting