public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed(Vector256 <Double> *pClsVar1 = &_clsVar1)
{
var result = Avx.RoundToNearestInteger(
Avx.LoadVector256((Double *)(pClsVar1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _dataTable.outArrayPtr);
}
}
public void RunReflectionScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
var result = typeof(AvxVnni).GetMethod(nameof(AvxVnni.MultiplyWideningAndAddSaturate), new Type[] { typeof(Vector128 <Int32>), typeof(Vector128 <Int16>), typeof(Vector128 <Int16>) })
.Invoke(null, new object[] {
Avx.LoadAlignedVector128((Int32 *)(_dataTable.inArray0Ptr)),
Avx.LoadAlignedVector128((Int16 *)(_dataTable.inArray1Ptr)),
Avx.LoadAlignedVector128((Int16 *)(_dataTable.inArray2Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector128 <Int32>)(result));
ValidateResult(_dataTable.inArray0Ptr, _dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
var result = typeof(Avx2).GetMethod(nameof(Avx2.Blend), new Type[] { typeof(Vector256 <UInt16>), typeof(Vector256 <UInt16>), typeof(byte) })
.Invoke(null, new object[] {
Avx.LoadAlignedVector256((UInt16 *)(_dataTable.inArray1Ptr)),
Avx.LoadAlignedVector256((UInt16 *)(_dataTable.inArray2Ptr)),
(byte)85
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector256 <UInt16>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__MultiplyAddAdjacentInt16 testClass)
{
fixed(Vector256 <Byte> *pFld1 = &_fld1)
fixed(Vector256 <SByte> *pFld2 = &_fld2)
{
var result = Avx2.MultiplyAddAdjacent(
Avx.LoadVector256((Byte *)(pFld1)),
Avx.LoadVector256((SByte *)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = Fma.MultiplyAddSubtract(
Avx.LoadVector256((Double *)(&test._fld1)),
Avx.LoadVector256((Double *)(&test._fld2)),
Avx.LoadVector256((Double *)(&test._fld3))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__AddSubtractSingle testClass)
{
fixed(Vector256 <Single> *pFld1 = &_fld1)
fixed(Vector256 <Single> *pFld2 = &_fld2)
{
var result = Avx.AddSubtract(
Avx.LoadVector256((Single *)(pFld1)),
Avx.LoadVector256((Single *)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
public void RunStructLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunStructLclFldScenario_Load));
var test = TestStruct.Create();
var result = Avx2.BlendVariable(
Avx.LoadVector256((Int32 *)(&test._fld1)),
Avx.LoadVector256((Int32 *)(&test._fld2)),
Avx.LoadVector256((Int32 *)(&test._fld3))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, test._fld3, _dataTable.outArrayPtr);
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed (Vector256<Single>* pFld1 = &_fld1)
{
var result = Avx.RoundToNearestInteger(
Avx.LoadVector256((Single*)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _dataTable.outArrayPtr);
}
}
public void RunReflectionScenario_LoadAligned()
{
var method = typeof(Avx).GetMethod(nameof(Avx.TestNotZAndNotC), new Type[] { typeof(Vector256 <UInt32>), typeof(Vector256 <UInt32>) });
if (method != null)
{
var result = method.Invoke(null, new object[] {
Avx.LoadAlignedVector256((UInt32 *)(_dataTable.inArray1Ptr)),
Avx.LoadAlignedVector256((UInt32 *)(_dataTable.inArray2Ptr))
});
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
}
}
public void RunReflectionScenario_LoadAligned()
{
var result = typeof(Avx).GetMethods(BindingFlags.Public | BindingFlags.Static)
.FirstOrDefault(mi => mi.Name == nameof(Avx.InsertVector128) && mi.IsGenericMethod)
.MakeGenericMethod(new[] { typeof(UInt32) })
.Invoke(null, new object[] {
Avx.LoadAlignedVector256((UInt32 *)(_dataTable.inArray1Ptr)),
LoadAlignedVector128((UInt32 *)(_dataTable.inArray2Ptr)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector256 <UInt32>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
var result = typeof(Fma).GetMethod(nameof(Fma.MultiplySubtractNegated), new Type[] { typeof(Vector256 <Double>), typeof(Vector256 <Double>), typeof(Vector256 <Double>) })
.Invoke(null, new object[] {
Avx.LoadAlignedVector256((Double *)(_dataTable.inArray1Ptr)),
Avx.LoadAlignedVector256((Double *)(_dataTable.inArray2Ptr)),
Avx.LoadAlignedVector256((Double *)(_dataTable.inArray3Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector256 <Double>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(Avx).GetMethod(nameof(Avx.BlendVariable), new Type[] { typeof(Vector256 <Single>), typeof(Vector256 <Single>), typeof(Vector256 <Single>) })
.Invoke(null, new object[] {
Avx.LoadVector256((Single *)(_dataTable.inArray1Ptr)),
Avx.LoadVector256((Single *)(_dataTable.inArray2Ptr)),
Avx.LoadVector256((Single *)(_dataTable.inArray3Ptr))
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector256 <Single>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.inArray3Ptr, _dataTable.outArrayPtr);
}
public void RunReflectionScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_Load));
var result = typeof(Avx).GetMethod(nameof(Avx.InsertVector128), new Type[] { typeof(Vector256 <UInt64>), typeof(UInt64 *), typeof(byte) })
.Invoke(null, new object[] {
Avx.LoadVector256((UInt64 *)(_dataTable.inArray1Ptr)),
Pointer.Box(_dataTable.inArray2Ptr, typeof(UInt64 *)),
(byte)1
});
Unsafe.Write(_dataTable.outArrayPtr, (Vector256 <UInt64>)(result));
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunStructFldScenario_Load(SimpleBinaryOpTest__MaxInt16 testClass)
{
fixed(Vector256 <Int16> *pFld1 = &_fld1)
fixed(Vector256 <Int16> *pFld2 = &_fld2)
{
var result = Avx2.Max(
Avx.LoadVector256((Int16 *)(pFld1)),
Avx.LoadVector256((Int16 *)(pFld2))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, testClass._dataTable.outArrayPtr);
}
}
private unsafe void RenderLoop(int iterations)
{
// Create a ray tracer, and create a reference to "sphere2" that we are going to bounce
var packetTracer = new Packet256Tracer(_width, _height);
var scene = packetTracer.DefaultScene;
var sphere2 = (SpherePacket256)scene.Things[0]; // The first item is assumed to be our sphere
var baseY = sphere2.Radiuses;
sphere2.Centers.Ys = sphere2.Radiuses;
// Timing determines how fast the ball bounces as well as diagnostics frames/second info
var renderingTime = new Stopwatch();
var totalTime = Stopwatch.StartNew();
// Keep rendering until the iteration count is hit
for (_frames = 0; _frames < iterations; _frames++)
{
// Or the rendering task has been canceled
if (_cancellation.IsCancellationRequested)
{
break;
}
// Get the next buffer
var rgbBuffer = _freeBuffers.GetObject();
// Determine the new position of the sphere based on the current time elapsed
float dy2 = 0.8f * MathF.Abs(MathF.Sin((float)(totalTime.ElapsedMilliseconds * Math.PI / 3000)));
sphere2.Centers.Ys = Avx.Add(baseY, Vector256.Create(dy2));
// Render the scene
renderingTime.Reset();
renderingTime.Start();
ParallelOptions options = new ParallelOptions
{
MaxDegreeOfParallelism = _degreeOfParallelism,
CancellationToken = _cancellation.Token
};
fixed(int *ptr = rgbBuffer)
{
packetTracer.RenderVectorized(scene, ptr);
}
renderingTime.Stop();
_framesPerSecond = (1000.0 / renderingTime.ElapsedMilliseconds);
_freeBuffers.PutObject(rgbBuffer);
}
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed(Vector256 <Byte> *pClsVar1 = &_clsVar1)
fixed(Vector256 <Byte> *pClsVar2 = &_clsVar2)
{
var result = Avx.TestNotZAndNotC(
Avx.LoadVector256((Byte *)(pClsVar1)),
Avx.LoadVector256((Byte *)(pClsVar2))
);
ValidateResult(_clsVar1, _clsVar2, result);
}
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed(Vector256 <Byte> *pFld1 = &_fld1)
fixed(Vector256 <Byte> *pFld2 = &_fld2)
{
var result = Avx.TestNotZAndNotC(
Avx.LoadVector256((Byte *)(pFld1)),
Avx.LoadVector256((Byte *)(pFld2))
);
ValidateResult(_fld1, _fld2, result);
}
}
public void RunStructFldScenario_Load(SimpleTernaryOpTest__BlendVariableInt32 testClass)
{
fixed(Vector256 <Int32> *pFld1 = &_fld1)
fixed(Vector256 <Int32> *pFld2 = &_fld2)
fixed(Vector256 <Int32> *pFld3 = &_fld3)
{
var result = Avx2.BlendVariable(
Avx.LoadVector256((Int32 *)(pFld1)),
Avx.LoadVector256((Int32 *)(pFld2)),
Avx.LoadVector256((Int32 *)(pFld3))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed (Vector256<Int32>* pClsVar1 = &_clsVar1)
fixed (Vector256<Int32>* pClsVar2 = &_clsVar2)
{
var result = Avx2.CompareGreaterThan(
Avx.LoadVector256((Int32*)(pClsVar1)),
Avx.LoadVector256((Int32*)(pClsVar2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed(Vector256 <Byte> *pFld1 = &_fld1)
fixed(Vector256 <Byte> *pFld2 = &_fld2)
{
var result = Avx2.Add(
Avx.LoadVector256((Byte *)(pFld1)),
Avx.LoadVector256((Byte *)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _dataTable.outArrayPtr);
}
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleUnaryOpTest__RoundToNearestIntegerDouble();
fixed(Vector256 <Double> *pFld1 = &test._fld1)
{
var result = Avx.RoundToNearestInteger(
Avx.LoadVector256((Double *)(pFld1))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, _dataTable.outArrayPtr);
}
}
public void RunClsVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario_Load));
fixed(Vector256 <Single> *pClsVar1 = &_clsVar1)
fixed(Vector256 <Single> *pClsVar2 = &_clsVar2)
{
var result = Avx.AndNot(
Avx.LoadVector256((Single *)(pClsVar1)),
Avx.LoadVector256((Single *)(pClsVar2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
}
public void RunStructFldScenario_Load(SimpleTernaryOpTest__MultiplyAddNegatedSingle testClass)
{
fixed(Vector256 <Single> *pFld1 = &_fld1)
fixed(Vector256 <Single> *pFld2 = &_fld2)
fixed(Vector256 <Single> *pFld3 = &_fld3)
{
var result = Fma.MultiplyAddNegated(
Avx.LoadVector256((Single *)(pFld1)),
Avx.LoadVector256((Single *)(pFld2)),
Avx.LoadVector256((Single *)(pFld3))
);
Unsafe.Write(testClass._dataTable.outArrayPtr, result);
testClass.ValidateResult(_fld1, _fld2, _fld3, testClass._dataTable.outArrayPtr);
}
}
public void RunReflectionScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunReflectionScenario_LoadAligned));
var method = typeof(Avx).GetMethod(nameof(Avx.TestZ), new Type[] { typeof(Vector256 <Byte>), typeof(Vector256 <Byte>) });
if (method != null)
{
var result = method.Invoke(null, new object[] {
Avx.LoadAlignedVector256((Byte *)(_dataTable.inArray1Ptr)),
Avx.LoadAlignedVector256((Byte *)(_dataTable.inArray2Ptr))
});
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, (bool)(result));
}
}
public float SumUsingAvx()
{
var values = this.values;
float sum = 0;
if (Avx.IsSupported)
{
// How may elements can we sum using vectors?
int vectorizableLength = values.Length - values.Length % Vector256 <float> .Count;
// Create vectors from the values and sum them into a temporary vector
var tempVector = Vector256 <float> .Zero;
unsafe
{
fixed(float *valuesPtr = values)
{
for (int i = 0; i < vectorizableLength; i += Vector256 <float> .Count)
{
var valuesVector = Avx.LoadVector256(valuesPtr + i);
tempVector = Avx.Add(tempVector, valuesVector);
}
}
}
// Sum the elements in the ttemporary vector
for (int iVector = 0; iVector < Vector256 <float> .Count; iVector++)
{
sum += tempVector.GetElement(iVector);
}
// Handle remaining elements
for (int i = vectorizableLength; i < values.Length; i++)
{
sum += values[i];
}
}
else
{
// non-AVX capable machines
for (int i = 0; i < values.Length; i++)
{
sum += values[i];
}
}
return(sum);
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new BooleanBinaryOpTest__TestNotZAndNotCByte();
fixed(Vector256 <Byte> *pFld1 = &test._fld1)
fixed(Vector256 <Byte> *pFld2 = &test._fld2)
{
var result = Avx.TestNotZAndNotC(
Avx.LoadVector256((Byte *)(pFld1)),
Avx.LoadVector256((Byte *)(pFld2))
);
ValidateResult(test._fld1, test._fld2, result);
}
}
private static unsafe void Convert16(byte *dest, byte *src, int vectorizable_bytes)
{
Vector256 <byte> ymm0;
var shmask = Vector256.Create((byte)
0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00,
0x0F, 0x0E, 0x0D, 0x0C, 0x0B, 0x0A, 0x09, 0x08,
0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00);
for (var j = 0; j < vectorizable_bytes; j += sizeof(Vector256 <byte>))
{
ymm0 = Avx.LoadVector256(src + j);
ymm0 = Avx2.Shuffle(ymm0, shmask);
Avx2.Store(dest + j, ymm0);
}
}
/* Routine optimized for unshuffling a buffer for a type size of 4 bytes. */
private static unsafe void unshuffle4_avx2(byte *dest, byte *src,
int vectorizable_elements, int total_elements)
{
int bytesoftype = 4;
int i;
int j;
var ymm0 = new Vector256 <byte> [4];
var ymm1 = new Vector256 <byte> [4];
for (i = 0; i < vectorizable_elements; i += sizeof(Vector256 <byte>))
{
/* Load 32 elements (128 bytes) into 4 YMM registers. */
byte *src_for_ith_element = src + i;
for (j = 0; j < 4; j++)
{
ymm0[j] = Avx.LoadVector256((src_for_ith_element + (j * total_elements)));
}
/* Shuffle bytes */
for (j = 0; j < 2; j++)
{
/* Compute the low 64 bytes */
ymm1[j] = Avx2.UnpackLow(ymm0[j * 2], ymm0[j * 2 + 1]);
/* Compute the hi 64 bytes */
ymm1[2 + j] = Avx2.UnpackHigh(ymm0[j * 2], ymm0[j * 2 + 1]);
}
/* Shuffle 2-byte words */
for (j = 0; j < 2; j++)
{
/* Compute the low 64 bytes */
ymm0[j] = Avx2.UnpackLow(ymm1[j * 2].AsInt16(), ymm1[j * 2 + 1].AsInt16()).AsByte();
/* Compute the hi 64 bytes */
ymm0[2 + j] = Avx2.UnpackHigh(ymm1[j * 2].AsInt16(), ymm1[j * 2 + 1].AsInt16()).AsByte();
}
ymm1[0] = Avx2.Permute2x128(ymm0[0], ymm0[2], 0x20);
ymm1[1] = Avx2.Permute2x128(ymm0[1], ymm0[3], 0x20);
ymm1[2] = Avx2.Permute2x128(ymm0[0], ymm0[2], 0x31);
ymm1[3] = Avx2.Permute2x128(ymm0[1], ymm0[3], 0x31);
/* Store the result vectors in proper order */
for (j = 0; j < 4; j++)
{
Avx2.Store((dest + (i * bytesoftype) + (j * sizeof(Vector256 <byte>))), ymm1[j]);
}
}
}
public void RunClassLclFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassLclFldScenario_Load));
var test = new SimpleBinaryOpTest__AndNotSingle();
fixed(Vector256 <Single> *pFld1 = &test._fld1)
fixed(Vector256 <Single> *pFld2 = &test._fld2)
{
var result = Avx.AndNot(
Avx.LoadVector256((Single *)(pFld1)),
Avx.LoadVector256((Single *)(pFld2))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(test._fld1, test._fld2, _dataTable.outArrayPtr);
}
}
public void RunClassFldScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClassFldScenario_Load));
fixed(Vector256 <Single> *pFld1 = &_fld1)
fixed(Vector256 <Single> *pFld2 = &_fld2)
fixed(Vector256 <Single> *pFld3 = &_fld3)
{
var result = Fma.MultiplyAddNegated(
Avx.LoadVector256((Single *)(pFld1)),
Avx.LoadVector256((Single *)(pFld2)),
Avx.LoadVector256((Single *)(pFld3))
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_fld1, _fld2, _fld3, _dataTable.outArrayPtr);
}
}
