public void RunFldScenario()
{
var result = Avx.Or(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public static Vector256 <T> Or <T>(Vector256 <T> left, Vector256 <T> right) where T : struct
{
if (typeof(T) == typeof(float))
{
if (Avx.IsSupported)
{
return(Avx.Or(left.AsSingle(), right.AsSingle()).As <float, T>());
}
}
if (typeof(T) == typeof(double))
{
if (Avx.IsSupported)
{
return(Avx.Or(left.AsDouble(), right.AsDouble()).As <double, T>());
}
}
if (Avx.IsSupported)
{
return(Avx.Or(left.AsSingle(), right.AsSingle()).As <float, T>());
}
return(SoftwareFallbacks.Or_Software(left, right));
}
public void RunStructFldScenario(SimpleBinaryOpTest__OrSingle testClass)
{
var result = Avx.Or(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunStructLclFldScenario()
{
var test = TestStruct.Create();
var result = Avx.Or(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunLclFldScenario()
{
var test = new SimpleBinaryOpTest__OrDouble();
var result = Avx.Or(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
var left = Unsafe.Read <Vector256 <Double> >(_dataTable.inArray1Ptr);
var right = Unsafe.Read <Vector256 <Double> >(_dataTable.inArray2Ptr);
var result = Avx.Or(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Avx.Or(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
var left = Avx.LoadAlignedVector256((Double *)(_dataTable.inArray1Ptr));
var right = Avx.LoadAlignedVector256((Double *)(_dataTable.inArray2Ptr));
var result = Avx.Or(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
var result = Avx.Or(
_clsVar1,
_clsVar2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunBasicScenario_LoadAligned()
{
var result = Avx.Or(
Avx.LoadAlignedVector256((Double *)(_dataTable.inArray1Ptr)),
Avx.LoadAlignedVector256((Double *)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_UnsafeRead()
{
var result = Avx.Or(
Unsafe.Read <Vector256 <Double> >(_dataTable.inArray1Ptr),
Unsafe.Read <Vector256 <Double> >(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleBinaryOpTest__OrSingle();
var result = Avx.Or(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Avx.Or(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));
var left = Avx.LoadAlignedVector256((Single *)(_dataTable.inArray1Ptr));
var right = Avx.LoadAlignedVector256((Single *)(_dataTable.inArray2Ptr));
var result = Avx.Or(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var left = Unsafe.Read <Vector256 <Single> >(_dataTable.inArray1Ptr);
var right = Unsafe.Read <Vector256 <Single> >(_dataTable.inArray2Ptr);
var result = Avx.Or(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read <Vector256 <Double> >(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read <Vector256 <Double> >(_dataTable.inArray2Ptr);
var result = Avx.Or(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));
var op1 = Avx.LoadAlignedVector256((Double *)(_dataTable.inArray1Ptr));
var op2 = Avx.LoadAlignedVector256((Double *)(_dataTable.inArray2Ptr));
var result = Avx.Or(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = Avx.Or(
Avx.LoadVector256((Single *)(_dataTable.inArray1Ptr)),
Avx.LoadVector256((Single *)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Avx.Or(
Unsafe.Read <Vector256 <Single> >(_dataTable.inArray1Ptr),
Unsafe.Read <Vector256 <Single> >(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = Avx.Or(
Avx.LoadVector256((Single *)(&test._fld1)),
Avx.LoadVector256((Single *)(&test._fld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__OrSingle testClass)
{
fixed(Vector256 <Single> *pFld1 = &_fld1)
fixed(Vector256 <Single> *pFld2 = &_fld2)
{
var result = Avx.Or(
Avx.LoadVector256((Single *)(pFld1)),
Avx.LoadVector256((Single *)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed(Vector256 <Double> *pClsVar1 = &_clsVar1)
fixed(Vector256 <Double> *pClsVar2 = &_clsVar2)
{
var result = Avx.Or(
Avx.LoadVector256((Double *)(pClsVar1)),
Avx.LoadVector256((Double *)(pClsVar2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed(Vector256 <Single> *pFld1 = &_fld1)
fixed(Vector256 <Single> *pFld2 = &_fld2)
{
var result = Avx.Or(
Avx.LoadVector256((Single *)(pFld1)),
Avx.LoadVector256((Single *)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
internal static unsafe (UnsafeMemory <BitState> bits, bool isValidBinary) ToBitStates(ReadOnlySpan <byte> valueText, BitAllocator bitAlloc)
{
UnsafeMemory <BitState> bitsMem = bitAlloc.GetBits(valueText.Length);
Span <BitState> bits = bitsMem.Span;
ulong isValidBinary = 0;
int index = 0;
if (Ssse3.IsSupported && bits.Length >= Vector128 <byte> .Count)
{
int vecBitCount = bits.Length / Vector128 <byte> .Count;
fixed(BitState *bitsPtr = bits)
{
fixed(byte *textPtr = valueText)
{
Vector128 <ulong> isValidBin = Vector128 <ulong> .Zero;
for (; index < vecBitCount; index++)
{
var charText = Avx.LoadVector128(textPtr + index * Vector128 <byte> .Count);
var byteText = Avx.Shuffle(charText, shuffleIdxs);
var firstBit = Avx.And(onlyFirstBit, Avx.Or(byteText, Avx.ShiftRightLogical(byteText.AsInt32(), 1).AsByte()));
var secondBit = Avx.And(onlySecondBit, Avx.ShiftRightLogical(byteText.AsInt32(), 5).AsByte());
var bytesAsBitStates = Avx.Or(firstBit, secondBit);
Avx.Store((byte *)bitsPtr + bits.Length - (index + 1) * Vector128 <byte> .Count, bytesAsBitStates);
isValidBin = Avx.Or(isValidBin, secondBit.AsUInt64());
}
isValidBinary = isValidBin.GetElement(0) | isValidBin.GetElement(1);
}
}
index *= Vector128 <byte> .Count;
}
for (; index < bits.Length; index++)
{
BitState bit = ToBitState(valueText[index]);
bits[bits.Length - index - 1] = bit;
isValidBinary |= (uint)bit & 0b10;
}
return(bitsMem, isValidBinary == 0);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleBinaryOpTest__OrSingle();
fixed(Vector256 <Single> *pFld1 = &test._fld1)
fixed(Vector256 <Single> *pFld2 = &test._fld2)
{
var result = Avx.Or(
Avx.LoadVector256((Single *)(pFld1)),
Avx.LoadVector256((Single *)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public unsafe static Vector128 <float> Log2(Vector128 <float> value)
{
// split value into exponent and mantissa parts
Vector128 <float> one = AvxExtensions.BroadcastScalarToVector128(MathV.One);
Vector128 <int> integerValue = value.AsInt32();
Vector128 <float> exponent = Avx.ConvertToVector128Single(Avx.Subtract(Avx.ShiftRightLogical(Avx.And(integerValue, MathV.FloatExponentMask128),
MathV.FloatMantissaBits),
MathV.FloatMantissaZero128));
Vector128 <float> mantissa = Avx.Or(Avx.And(integerValue, MathV.FloatMantissaMask128).AsSingle(), one);
// evaluate mantissa polynomial
Vector128 <float> beta1 = AvxExtensions.BroadcastScalarToVector128(MathV.Log2Beta1);
Vector128 <float> beta2 = AvxExtensions.BroadcastScalarToVector128(MathV.Log2Beta2);
Vector128 <float> beta3 = AvxExtensions.BroadcastScalarToVector128(MathV.Log2Beta3);
Vector128 <float> beta4 = AvxExtensions.BroadcastScalarToVector128(MathV.Log2Beta4);
Vector128 <float> beta5 = AvxExtensions.BroadcastScalarToVector128(MathV.Log2Beta5);
Vector128 <float> x = Avx.Subtract(mantissa, one);
Vector128 <float> polynomial = Avx.Multiply(beta1, x);
Vector128 <float> x2 = Avx.Multiply(x, x);
polynomial = Avx.Add(polynomial, Avx.Multiply(beta2, x2));
Vector128 <float> x3 = Avx.Multiply(x2, x);
polynomial = Avx.Add(polynomial, Avx.Multiply(beta3, x3));
Vector128 <float> x4 = Avx.Multiply(x3, x);
polynomial = Avx.Add(polynomial, Avx.Multiply(beta4, x4));
Vector128 <float> x5 = Avx.Multiply(x4, x);
polynomial = Avx.Add(polynomial, Avx.Multiply(beta5, x5));
// form logarithm
return(Avx.Add(exponent, polynomial));
}
public static f32 Or(f32 lhs, f32 rhs) => Avx.Or(lhs, rhs);
