public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = Avx.BroadcastVector128ToVector256(
(Single *)(_dataTable.inArrayPtr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
static unsafe int Main(string[] args)
{
int testResult = Pass;
if (Avx.IsSupported)
{
using (TestTable <float> floatTable = new TestTable <float>(new float[8] {
1, -5, 100, 0, 1, 2, 3, 4
}, new float[8]))
{
var vf = Avx.BroadcastVector128ToVector256((float *)(floatTable.inArrayPtr));
Unsafe.Write(floatTable.outArrayPtr, vf);
if (!floatTable.CheckResult((x, y) => BitConverter.SingleToInt32Bits(x) == BitConverter.SingleToInt32Bits(y)))
{
Console.WriteLine("AVX BroadcastVector128ToVector256 failed on float:");
foreach (var item in floatTable.outArray)
{
Console.Write(item + ", ");
}
Console.WriteLine();
testResult = Fail;
}
}
using (TestTable <double> doubleTable = new TestTable <double>(new double[4] {
1, -5, 100, 0
}, new double[4]))
{
var vf = Avx.BroadcastVector128ToVector256((double *)(doubleTable.inArrayPtr));
Unsafe.Write(doubleTable.outArrayPtr, vf);
if (!doubleTable.CheckResult((x, y) => BitConverter.DoubleToInt64Bits(x) == BitConverter.DoubleToInt64Bits(y)))
{
Console.WriteLine("AVX BroadcastVector128ToVector256 failed on double:");
foreach (var item in doubleTable.outArray)
{
Console.Write(item + ", ");
}
Console.WriteLine();
testResult = Fail;
}
}
}
return(testResult);
}
unsafe public static void ConvertFloat3A(byte *ipstart, byte *opstart, float *lutstart, int lutmax, int cb)
{
Debug.Assert(ipstart == opstart);
float *ip = (float *)ipstart, ipe = (float *)(ipstart + cb);
float *lp = lutstart;
#if HWINTRINSICS
if (Avx2.IsSupported)
{
var vgmsk = Avx.BroadcastVector128ToVector256((float *)Unsafe.AsPointer(ref MemoryMarshal.GetReference(HWIntrinsics.GatherMask3x)));
var vgmax = Vector256.Create((float)lutmax);
var vzero = Vector256 <float> .Zero;
var vfone = Vector256.Create(1f);
var vione = Vector256.Create(1);
ipe -= Vector256 <float> .Count;
while (ip <= ipe)
{
var vf = Avx.Max(vzero, Avx.LoadVector256(ip));
var va = Avx.Shuffle(vf, vf, HWIntrinsics.ShuffleMaskAlpha);
vf = Avx.Multiply(vf, Avx.Multiply(vgmax, Avx.Reciprocal(va)));
vf = Avx.Min(vf, vgmax);
var vi = Avx.ConvertToVector256Int32WithTruncation(vf);
var vfi = Avx.ConvertToVector256Single(vi);
var vl = Avx2.GatherMaskVector256(vfone, lp, vi, vgmsk, sizeof(float));
var vh = Avx2.GatherMaskVector256(vfone, lp, Avx2.Add(vi, vione), vgmsk, sizeof(float));
vf = HWIntrinsics.Lerp(vl, vh, Avx.Subtract(vf, vfi));
vf = Avx.Multiply(vf, va);
Avx.Store(ip, vf);
ip += Vector256 <float> .Count;
}
ipe += Vector256 <float> .Count;
}
#endif
{
var vlmax = new Vector4(lutmax);
var vzero = Vector4.Zero;
float famin = new Vector4(1 / 1024f).X;
while (ip < ipe)
{
var vf = Unsafe.ReadUnaligned <Vector4>(ip);
float f3 = vf.W;
if (f3 < famin)
{
Unsafe.WriteUnaligned(ip, vzero);
}
else
{
vf = (vf * vlmax / f3).Clamp(vzero, vlmax);
float f0 = vf.X;
float f1 = vf.Y;
float f2 = vf.Z;
uint i0 = (uint)f0;
uint i1 = (uint)f1;
uint i2 = (uint)f2;
ip[0] = Lerp(lp[i0], lp[i0 + 1], f0 - (int)i0) * f3;
ip[1] = Lerp(lp[i1], lp[i1 + 1], f1 - (int)i1) * f3;
ip[2] = Lerp(lp[i2], lp[i2 + 1], f2 - (int)i2) * f3;
}
ip += 4;
}
}
}
