static unsafe int Main(string[] args)
{
int testResult = Pass;
if (Sse.IsSupported)
{
using (TestTable <float> floatTable = new TestTable <float>(new float[4] {
1, -5, 100, 0
}, new float[4] {
22, -1, -50, 0
}, new float[4]))
{
var vf1 = Unsafe.Read <Vector128 <float> >(floatTable.inArray1Ptr);
var vf2 = Unsafe.Read <Vector128 <float> >(floatTable.inArray2Ptr);
var vf3 = Sse.CompareLessThanOrEqual(vf1, vf2);
Unsafe.Write(floatTable.outArrayPtr, vf3);
if (!floatTable.CheckResult((x, y, z) => BitConverter.SingleToInt32Bits(z) == ((x <= y) ? -1 : 0)))
{
Console.WriteLine("SSE CompareLessThanOrEqual failed on float:");
foreach (var item in floatTable.outArray)
{
Console.Write(item + ", ");
}
Console.WriteLine();
testResult = Fail;
}
}
}
return(testResult);
}
public void RunStructFldScenario(SimpleBinaryOpTest__CompareLessThanOrEqualSingle testClass)
{
var result = Sse.CompareLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
public void RunFldScenario()
{
var result = Sse.CompareLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunLclFldScenario()
{
var test = new SimpleBinaryOpTest__CompareLessThanOrEqualSingle();
var result = Sse.CompareLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario()
{
var test = TestStruct.Create();
var result = Sse.CompareLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClassFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario));
var result = Sse.CompareLessThanOrEqual(_fld1, _fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
var left = Sse.LoadAlignedVector128((Single *)(_dataTable.inArray1Ptr));
var right = Sse.LoadAlignedVector128((Single *)(_dataTable.inArray2Ptr));
var result = Sse.CompareLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
var left = Unsafe.Read <Vector128 <Single> >(_dataTable.inArray1Ptr);
var right = Unsafe.Read <Vector128 <Single> >(_dataTable.inArray2Ptr);
var result = Sse.CompareLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public static Vector128 <float> CompareLessThanOrEqual(Vector4FParam1_3 left, Vector4FParam1_3 right)
{
if (Sse.IsSupported)
{
return(Sse.CompareLessThanOrEqual(left, right));
}
return(CompareLessThanOrEqual_Software(left, right));
}
public void RunClassLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario));
var test = new SimpleBinaryOpTest__CompareLessThanOrEqualSingle();
var result = Sse.CompareLessThanOrEqual(test._fld1, test._fld2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
var result = Sse.CompareLessThanOrEqual(
_clsVar1,
_clsVar2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunBasicScenario_LoadAligned()
{
var result = Sse.CompareLessThanOrEqual(
Sse.LoadAlignedVector128((Single *)(_dataTable.inArray1Ptr)),
Sse.LoadAlignedVector128((Single *)(_dataTable.inArray2Ptr))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_UnsafeRead()
{
var result = Sse.CompareLessThanOrEqual(
Unsafe.Read <Vector128 <Single> >(_dataTable.inArray1Ptr),
Unsafe.Read <Vector128 <Single> >(_dataTable.inArray2Ptr)
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunStructLclFldScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario));
var test = TestStruct.Create();
var result = Sse.CompareLessThanOrEqual(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 op1 = Sse.LoadAlignedVector128((Single *)(_dataTable.inArray1Ptr));
var op2 = Sse.LoadAlignedVector128((Single *)(_dataTable.inArray2Ptr));
var result = Sse.CompareLessThanOrEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var op1 = Unsafe.Read <Vector128 <Single> >(_dataTable.inArray1Ptr);
var op2 = Unsafe.Read <Vector128 <Single> >(_dataTable.inArray2Ptr);
var result = Sse.CompareLessThanOrEqual(op1, op2);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(op1, op2, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
var left = Sse.LoadVector128((Single *)(_dataTable.inArray1Ptr));
var right = Sse.LoadVector128((Single *)(_dataTable.inArray2Ptr));
var result = Sse.CompareLessThanOrEqual(left, right);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__CompareLessThanOrEqualSingle testClass)
{
fixed(Vector128 <Single> *pFld1 = &_fld1)
fixed(Vector128 <Single> *pFld2 = &_fld2)
{
var result = Sse.CompareLessThanOrEqual(
Sse.LoadVector128((Single *)(pFld1)),
Sse.LoadVector128((Single *)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed(Vector128 <Single> *pFld1 = &_fld1)
fixed(Vector128 <Single> *pFld2 = &_fld2)
{
var result = Sse.CompareLessThanOrEqual(
Sse.LoadVector128((Single *)(pFld1)),
Sse.LoadVector128((Single *)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public static m32 LessThanOrEqual(f32 lhs, f32 rhs) => Sse.CompareLessThanOrEqual(lhs, rhs).AsInt32();
public static Vector128 <float> _mm_cmple_ps(Vector128 <float> left, Vector128 <float> right)
{
return(Sse.CompareLessThanOrEqual(left, right));
}
public static Vector128 <float> op_LessThanOrEqual(Vector128 <float> left, Vector128 <float> right) => Sse.CompareLessThanOrEqual(left, right);
public unsafe static void Run(World world)
{
if (!Sse.IsSupported || !Sse2.IsSupported)
{
throw new Exception("Your processor must support SSE and SSE2 to run this.");
}
var charCount = world.AllCharacters.Count;
var chars = stackalloc CharData[charCount];
for (var i = 0; i < charCount; i++)
{
var characterActor = world.AllCharacters[i];
var allegianceComponent = characterActor.FindComponent <AllegianceComponent>();
chars[i] = new CharData
{
X = characterActor.Position.X,
Y = characterActor.Position.Y,
Z = characterActor.Position.Z,
Allegiance = allegianceComponent.Allegiance
};
}
var doorData = world.DoorData;
var doorCount = doorData.Count;
for (var d = 0; d < doorCount; d += 4)
{
var doorX = Sse.LoadAlignedVector128(doorData.X.AlignedPointer + d);
var doorY = Sse.LoadAlignedVector128(doorData.Y.AlignedPointer + d);
var doorZ = Sse.LoadAlignedVector128(doorData.Z.AlignedPointer + d);
var doorR2 = Sse.LoadAlignedVector128(doorData.RadiusSquared.AlignedPointer + d);
var doorA = Sse2.LoadAlignedVector128(doorData.Allegiance.AlignedPointer + d);
var state = Vector128 <uint> .Zero;
for (var cc = 0; cc < charCount; cc++)
{
ref var c = ref chars[cc];
var charX = Vector128.Create(c.X);
var charY = Vector128.Create(c.Y);
var charZ = Vector128.Create(c.Z);
var charA = Vector128.Create(c.Allegiance);
var ddx = Sse.Subtract(doorX, charX);
var ddy = Sse.Subtract(doorY, charY);
var ddz = Sse.Subtract(doorZ, charZ);
var dtx = Sse.Multiply(ddx, ddx);
var dty = Sse.Multiply(ddy, ddy);
var dtz = Sse.Multiply(ddz, ddz);
var dst2 = Sse.Add(Sse.Add(dtx, dty), dtz);
var rmask = Sse.CompareLessThanOrEqual(dst2, doorR2);
var amask = Sse2.CompareEqual(charA, doorA);
var mask = Sse2.And(rmask.AsUInt32(), amask);
state = Sse2.Or(mask, state);
}
Sse2.StoreAligned(doorData.ShouldBeOpen.AlignedPointer + d, state);
}
public static unsafe void ComputeSingle(
uint[,] iterations,
int startScanline, int increment,
double offsetX, double offsetY,
double zoom,
uint maxIterations,
ref bool cancel)
{
const int stride = 4;
int height = iterations.GetLength(0);
int width = iterations.GetLength(1);
var maxIter = Vector128.Create((float)maxIterations);
var limit = Vector128.Create(4.0f);
var one = Vector128.Create(1.0f);
var two = Vector128.Create(2.0f);
var results = stackalloc float[stride];
for (int i = startScanline; i < height && !cancel; i += increment)
{
for (int j = 0; j < width && !cancel; j += stride)
{
var c0 = Impl.GetPointCoordinate(j + 0, i, width, height, offsetX, offsetY, zoom);
var c1 = Impl.GetPointCoordinate(j + 1, i, width, height, offsetX, offsetY, zoom);
var c2 = Impl.GetPointCoordinate(j + 2, i, width, height, offsetX, offsetY, zoom);
var c3 = Impl.GetPointCoordinate(j + 3, i, width, height, offsetX, offsetY, zoom);
var cr = Vector128.Create((float)c0.X, (float)c1.X, (float)c2.X, (float)c3.X);
var ci = Vector128.Create((float)c0.Y, (float)c1.Y, (float)c2.Y, (float)c3.Y);
var zr = cr;
var zi = ci;
var it = Vector128.Create(0f);
for (;;)
{
var zr2 = Sse.Multiply(zr, zr);
var zi2 = Sse.Multiply(zi, zi);
var squaredMagnitude = Sse.Add(zr2, zi2);
var cond = Sse.And(
Sse.CompareLessThanOrEqual(squaredMagnitude, limit),
Sse.CompareLessThanOrEqual(it, maxIter));
if (Sse.MoveMask(cond) == 0)
{
Sse.Store(results, it);
if (j + 0 < width)
{
iterations[i, j + 0] = (uint)results[0] % maxIterations;
}
if (j + 1 < width)
{
iterations[i, j + 1] = (uint)results[1] % maxIterations;
}
if (j + 2 < width)
{
iterations[i, j + 2] = (uint)results[2] % maxIterations;
}
if (j + 3 < width)
{
iterations[i, j + 3] = (uint)results[3] % maxIterations;
}
break;
}
zi = Sse.Add(Sse.Multiply(two, Sse.Multiply(zr, zi)), ci);
zr = Sse.Add(Sse.Subtract(zr2, zi2), cr);
it = Sse.Add(it, Sse.And(one, cond));
}
}
}
}
