public void RunStructFldScenario(SimpleBinaryOpTest__MaskLoadSingle testClass)
{
var result = Avx.MaskLoad((Single *)testClass._dataTable.inArray1Ptr, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(testClass._dataTable.inArray1Ptr, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Avx.MaskLoad((Single *)_dataTable.inArray1Ptr, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _fld2, _dataTable.outArrayPtr);
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleBinaryOpTest__MaskLoadSingle();
var result = Avx.MaskLoad((Single *)_dataTable.inArray1Ptr, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Avx.MaskLoad((Double *)_dataTable.inArray1Ptr, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, test._fld2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));
var left = (Single *)_dataTable.inArray1Ptr;
var right = Avx.LoadAlignedVector256((Single *)(_dataTable.inArray2Ptr));
var result = Avx.MaskLoad(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var left = (Double *)_dataTable.inArray1Ptr;
var right = Unsafe.Read <Vector128 <Double> >(_dataTable.inArray2Ptr);
var result = Avx.MaskLoad(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = Avx.MaskLoad(
(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.MaskLoad(
(Double *)_dataTable.inArray1Ptr,
Unsafe.Read <Vector128 <Double> >(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
private static bool ProblemWithMaskLoad_Avx()
{
const double Mask = -0.0;
var data = stackalloc double[2];
data[0] = 1;
data[1] = 1;
JitUse(data);
// Make sure we take mask into account.
var v1 = Avx.MaskLoad(data, Vector128.Create(0, Mask));
if (v1.GetElement(0) == 0)
{
var v2 = Avx.MaskLoad(data, Vector128.Create(Mask, 0));
if (v2.GetElement(0) == 0)
{
return(true);
}
}
return(false);
}
static unsafe int Main(string[] args)
{
int testResult = Pass;
if (Avx.IsSupported)
{
using (TestTable <float, uint> floatTable = new TestTable <float, uint>(new float[8] {
1, -5, 100, 0, 1, 2, 3, 4
}, new uint[8] {
uint.MaxValue, uint.MaxValue, 0, 0, uint.MaxValue, uint.MaxValue, 0, 0
}, new float[8]))
{
Vector256 <float> vf = Avx.MaskLoad((float *)(floatTable.inArrayPtr), Avx.LoadVector256((float *)(floatTable.maskArrayPtr)));
Unsafe.Write(floatTable.outArrayPtr, vf);
if (!floatTable.CheckResult((x, m, y) => m == uint.MaxValue ? BitConverter.SingleToInt32Bits(x) == BitConverter.SingleToInt32Bits(y) : BitConverter.SingleToInt32Bits(y) == 0))
{
Console.WriteLine("AVX MaskLoad failed on float:");
foreach (var item in floatTable.outArray)
{
Console.Write(item + ", ");
}
Console.WriteLine();
testResult = Fail;
}
}
using (TestTable <double, ulong> doubleTable = new TestTable <double, ulong>(new double[4] {
1, -5, 100, 0
}, new ulong[4] {
0, ulong.MaxValue, ulong.MaxValue, 0
}, new double[4]))
{
Vector256 <double> vf = Avx.MaskLoad((double *)(doubleTable.inArrayPtr), Avx.LoadVector256((double *)(doubleTable.maskArrayPtr)));
Unsafe.Write(doubleTable.outArrayPtr, vf);
if (!doubleTable.CheckResult((x, m, y) => m == ulong.MaxValue ? BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y) : BitConverter.DoubleToInt64Bits(y) == 0))
{
Console.WriteLine("AVX MaskLoad failed on double:");
foreach (var item in doubleTable.outArray)
{
Console.Write(item + ", ");
}
Console.WriteLine();
testResult = Fail;
}
}
using (TestTable <float, uint> floatTable = new TestTable <float, uint>(new float[4] {
1, -5, 100, 0
}, new uint[4] {
uint.MaxValue, 0, 0, uint.MaxValue
}, new float[4]))
{
Vector128 <float> vf = Avx.MaskLoad((float *)(floatTable.inArrayPtr), Sse.LoadVector128((float *)(floatTable.maskArrayPtr)));
Unsafe.Write(floatTable.outArrayPtr, vf);
if (!floatTable.CheckResult((x, m, y) => m == uint.MaxValue ? BitConverter.SingleToInt32Bits(x) == BitConverter.SingleToInt32Bits(y) : BitConverter.SingleToInt32Bits(y) == 0))
{
Console.WriteLine("AVX MaskLoad failed on Vector128 float:");
foreach (var item in floatTable.outArray)
{
Console.Write(item + ", ");
}
Console.WriteLine();
testResult = Fail;
}
}
using (TestTable <double, ulong> doubleTable = new TestTable <double, ulong>(new double[2] {
1, -5
}, new ulong[2] {
0, ulong.MaxValue
}, new double[2]))
{
Vector128 <double> vf = Avx.MaskLoad((double *)(doubleTable.inArrayPtr), Sse2.LoadVector128((double *)(doubleTable.maskArrayPtr)));
Unsafe.Write(doubleTable.outArrayPtr, vf);
if (!doubleTable.CheckResult((x, m, y) => m == ulong.MaxValue ? BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y) : BitConverter.DoubleToInt64Bits(y) == 0))
{
Console.WriteLine("AVX MaskLoad failed on double:");
foreach (var item in doubleTable.outArray)
{
Console.Write(item + ", ");
}
Console.WriteLine();
testResult = Fail;
}
}
}
return(testResult);
}
