public void RunClsVarScenario()
{
var result = Sse41.Insert(
_clsVar,
(uint)2,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar, _dataTable.outArrayPtr);
}
public void RunBasicScenario_UnsafeRead()
{
var result = Sse41.Insert(
Unsafe.Read <Vector128 <Single> >(_dataTable.inArray1Ptr),
Unsafe.Read <Vector128 <Single> >(_dataTable.inArray2Ptr),
2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_UnsafeRead()
{
var result = Sse41.Insert(
Unsafe.Read <Vector128 <UInt32> >(_dataTable.inArrayPtr),
(uint)2,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_LoadAligned()
{
var result = Sse41.Insert(
Sse2.LoadAlignedVector128((UInt32 *)(_dataTable.inArrayPtr)),
(uint)2,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));
var left = Sse.LoadAlignedVector128((Single *)(_dataTable.inArray1Ptr));
var right = LoadAlignedVector128((Single *)(_dataTable.inArray2Ptr));
var result = Sse41.Insert(left, right, 129);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_UnsafeRead));
var left = Unsafe.Read <Vector128 <Single> >(_dataTable.inArray1Ptr);
var right = Unsafe.Read <Vector128 <Single> >(_dataTable.inArray2Ptr);
var result = Sse41.Insert(left, right, 129);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(left, right, _dataTable.outArrayPtr);
}
public void RunBasicScenario_LoadAligned()
{
var result = Sse41.Insert(
Sse.LoadAlignedVector128((Single *)(_dataTable.inArrayPtr)),
(float)2,
217
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
var result = Sse41.Insert(
Sse2.LoadVector128((UInt64 *)(_dataTable.inArrayPtr)),
(ulong)2,
129
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
var result = Sse41.Insert(
Sse.LoadVector128((Single *)(_dataTable.inArray1Ptr)),
LoadVector128((Single *)(_dataTable.inArray2Ptr)),
2
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_LoadAligned));
Byte localData = (byte)2;
var firstOp = Sse2.LoadAlignedVector128((Byte *)(_dataTable.inArrayPtr));
var result = Sse41.Insert(firstOp, localData, 129);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, localData, _dataTable.outArrayPtr);
}
public void RunLclVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario));
Byte localData = (byte)2;
var firstOp = Unsafe.Read <Vector128 <Byte> >(_dataTable.inArrayPtr);
var result = Sse41.Insert(firstOp, localData, 129);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, localData, _dataTable.outArrayPtr);
}
public void RunLclVarScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunLclVarScenario_Load));
UInt32 localData = (uint)2;
var firstOp = Sse2.LoadVector128((UInt32 *)(_dataTable.inArrayPtr));
var result = Sse41.Insert(firstOp, localData, 1);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(firstOp, localData, _dataTable.outArrayPtr);
}
public void RunBasicScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario));
var result = Sse41.Insert(
Unsafe.Read <Vector128 <Byte> >(_dataTable.inArrayPtr),
(byte)2,
129
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, (byte)2, _dataTable.outArrayPtr);
}
public void RunClsVarScenario()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunClsVarScenario));
var result = Sse41.Insert(
_clsVar1,
_clsVar2,
4
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_clsVar1, _clsVar2, _dataTable.outArrayPtr);
}
public void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
var result = Sse41.Insert(
Sse2.LoadVector128((UInt32 *)(_dataTable.inArrayPtr)),
(uint)2,
129
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_UnsafeRead()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_UnsafeRead));
var result = Sse41.Insert(
Unsafe.Read <Vector128 <Single> >(_dataTable.inArray1Ptr),
Unsafe.Read <Vector128 <Single> >(_dataTable.inArray2Ptr),
4
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public void RunBasicScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
var result = Sse41.Insert(
Sse.LoadAlignedVector128((Single *)(_dataTable.inArray1Ptr)),
LoadAlignedVector128((Single *)(_dataTable.inArray2Ptr)),
4
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArray1Ptr, _dataTable.inArray2Ptr, _dataTable.outArrayPtr);
}
public unsafe void RunBasicScenario_LoadAligned()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_LoadAligned));
Byte localData = (byte)2;
Byte *ptr = &localData;
var result = Sse41.Insert(
Sse2.LoadAlignedVector128((Byte *)(_dataTable.inArrayPtr)),
*ptr,
129
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, *ptr, _dataTable.outArrayPtr);
}
public unsafe void RunBasicScenario_Load()
{
TestLibrary.TestFramework.BeginScenario(nameof(RunBasicScenario_Load));
Int32 localData = (int)2;
Int32 *ptr = &localData;
var result = Sse41.Insert(
Sse2.LoadVector128((Int32 *)(_dataTable.inArrayPtr)),
*ptr,
1
);
Unsafe.Write(_dataTable.outArrayPtr, result);
ValidateResult(_dataTable.inArrayPtr, *ptr, _dataTable.outArrayPtr);
}
public static Vector128 <float> VectorInsertSingle(float value, Vector128 <float> vector, byte index)
{
if (Sse41.IsSupported)
{
//Note: The if/else if is necessary to enable the JIT to
//produce a single INSERTPS instruction instead of the
//jump table fallback.
if (index == 0)
{
return(Sse41.Insert(vector, value, 0x00));
}
else if (index == 1)
{
return(Sse41.Insert(vector, value, 0x10));
}
else if (index == 2)
{
return(Sse41.Insert(vector, value, 0x20));
}
else if (index == 3)
{
return(Sse41.Insert(vector, value, 0x30));
}
else
{
throw new ArgumentOutOfRangeException(nameof(index));
}
}
else if (Sse2.IsSupported)
{
int intValue = BitConverter.SingleToInt32Bits(value);
ushort low = (ushort)(intValue >> 0);
ushort high = (ushort)(intValue >> 16);
Vector128 <ushort> shortVector = Sse.StaticCast <float, ushort>(vector);
shortVector = Sse2.Insert(shortVector, low, (byte)(index * 2 + 0));
shortVector = Sse2.Insert(shortVector, high, (byte)(index * 2 + 1));
return(Sse.StaticCast <ushort, float>(shortVector));
}
throw new PlatformNotSupportedException();
}
private Vector128 <byte> LongToUtf8_16(long value)
{
Vector128 <sbyte> v;
if (Sse41.X64.IsSupported)
{
v = Vector128.CreateScalarUnsafe(value).AsSByte();
}
else
{
var value0 = (int)value;
var value1 = (int)((ulong)value >> 32);
v = Sse41.Insert(Vector128.CreateScalarUnsafe(value0), value1, 1).AsSByte();
}
var vector = Ssse3.Shuffle(v, ShuffleMask).AsInt16();
return(Sse2.Add(Sse2.Or(Sse2.ShiftRightLogical(vector, 4), Sse2.ShiftLeftLogical(Sse2.And(vector, LowMask), 8)), ShortCharA).AsByte());
}
public static Vector128 <float> VectorInsertSingle(float Value, Vector128 <float> Vector, byte Index)
{
if (Sse41.IsSupported)
{
return(Sse41.Insert(Vector, Value, (byte)(Index << 4)));
}
else if (Sse2.IsSupported)
{
int IntValue = BitConverter.SingleToInt32Bits(Value);
ushort Low = (ushort)(IntValue >> 0);
ushort High = (ushort)(IntValue >> 16);
Vector128 <ushort> ShortVector = Sse.StaticCast <float, ushort>(Vector);
ShortVector = Sse2.Insert(ShortVector, Low, (byte)(Index * 2 + 0));
ShortVector = Sse2.Insert(ShortVector, High, (byte)(Index * 2 + 1));
return(Sse.StaticCast <ushort, float>(ShortVector));
}
throw new PlatformNotSupportedException();
}
public static Vector128 <float> VectorInsertInt(ulong Value, Vector128 <float> Vector, byte Index, int Size)
{
if (Sse41.IsSupported)
{
switch (Size)
{
case 0:
return(Sse.StaticCast <byte, float>(Sse41.Insert(Sse.StaticCast <float, byte>(Vector), (byte)Value, Index)));
case 1:
return(Sse.StaticCast <ushort, float>(Sse2.Insert(Sse.StaticCast <float, ushort>(Vector), (ushort)Value, Index)));
case 2:
return(Sse.StaticCast <uint, float>(Sse41.Insert(Sse.StaticCast <float, uint>(Vector), (uint)Value, Index)));
case 3:
return(Sse.StaticCast <ulong, float>(Sse41.Insert(Sse.StaticCast <float, ulong>(Vector), Value, Index)));
}
throw new ArgumentOutOfRangeException(nameof(Size));
}
else if (Sse2.IsSupported)
{
Vector128 <ushort> ShortVector = Sse.StaticCast <float, ushort>(Vector);
int ShortIdx = Size == 0
? Index >> 1
: Index << (Size - 1);
switch (Size)
{
case 0:
{
ushort ShortVal = Sse2.Extract(Sse.StaticCast <float, ushort>(Vector), (byte)ShortIdx);
int Shift = (Index & 1) * 8;
ShortVal &= (ushort)(0xff00 >> Shift);
ShortVal |= (ushort)((byte)Value << Shift);
return(Sse.StaticCast <ushort, float>(Sse2.Insert(ShortVector, ShortVal, (byte)ShortIdx)));
}
case 1:
return(Sse.StaticCast <ushort, float>(Sse2.Insert(Sse.StaticCast <float, ushort>(Vector), (ushort)Value, Index)));
case 2:
case 3:
{
ShortVector = Sse2.Insert(ShortVector, (ushort)(Value >> 0), (byte)(ShortIdx + 0));
ShortVector = Sse2.Insert(ShortVector, (ushort)(Value >> 16), (byte)(ShortIdx + 1));
if (Size == 3)
{
ShortVector = Sse2.Insert(ShortVector, (ushort)(Value >> 32), (byte)(ShortIdx + 2));
ShortVector = Sse2.Insert(ShortVector, (ushort)(Value >> 48), (byte)(ShortIdx + 3));
}
return(Sse.StaticCast <ushort, float>(ShortVector));
}
}
throw new ArgumentOutOfRangeException(nameof(Size));
}
throw new PlatformNotSupportedException();
}
public static Vector128 <byte> _mm_insert_epi8(Vector128 <byte> value, byte data, byte index)
{
return(Sse41.Insert(value, data, index));
}
public static Vector128 <uint> _mm_insert_epi32(Vector128 <uint> value, uint data, byte index)
{
return(Sse41.Insert(value, data, index));
}
public static Vector128 <float> _mm_insert_ps(Vector128 <float> value, Vector128 <float> data, byte index)
{
return(Sse41.Insert(value, data, index));
}
public static Vector128 <float> Sse41VectorInsertScalarSingle(float value, Vector128 <float> vector)
{
//Note: 0b1110 is the mask to zero the upper bits.
return(Sse41.Insert(vector, value, 0b1110));
}
public static Vector128 <float> VectorInsertInt(ulong value, Vector128 <float> vector, byte index, int size)
{
if (Sse41.IsSupported)
{
if (size == 0)
{
return(Sse.StaticCast <byte, float>(Sse41.Insert(Sse.StaticCast <float, byte>(vector), (byte)value, index)));
}
else if (size == 1)
{
return(Sse.StaticCast <ushort, float>(Sse2.Insert(Sse.StaticCast <float, ushort>(vector), (ushort)value, index)));
}
else if (size == 2)
{
return(Sse.StaticCast <uint, float>(Sse41.Insert(Sse.StaticCast <float, uint>(vector), (uint)value, index)));
}
else if (size == 3)
{
return(Sse.StaticCast <ulong, float>(Sse41.Insert(Sse.StaticCast <float, ulong>(vector), value, index)));
}
else
{
throw new ArgumentOutOfRangeException(nameof(size));
}
}
else if (Sse2.IsSupported)
{
Vector128 <ushort> shortVector = Sse.StaticCast <float, ushort>(vector);
int shortIdx = size == 0
? index >> 1
: index << (size - 1);
if (size == 0)
{
ushort shortVal = Sse2.Extract(Sse.StaticCast <float, ushort>(vector), (byte)shortIdx);
int shift = (index & 1) * 8;
shortVal &= (ushort)(0xff00 >> shift);
shortVal |= (ushort)((byte)value << shift);
return(Sse.StaticCast <ushort, float>(Sse2.Insert(shortVector, shortVal, (byte)shortIdx)));
}
else if (size == 1)
{
return(Sse.StaticCast <ushort, float>(Sse2.Insert(Sse.StaticCast <float, ushort>(vector), (ushort)value, index)));
}
else if (size == 2 || size == 3)
{
shortVector = Sse2.Insert(shortVector, (ushort)(value >> 0), (byte)(shortIdx + 0));
shortVector = Sse2.Insert(shortVector, (ushort)(value >> 16), (byte)(shortIdx + 1));
if (size == 3)
{
shortVector = Sse2.Insert(shortVector, (ushort)(value >> 32), (byte)(shortIdx + 2));
shortVector = Sse2.Insert(shortVector, (ushort)(value >> 48), (byte)(shortIdx + 3));
}
return(Sse.StaticCast <ushort, float>(shortVector));
}
else
{
throw new ArgumentOutOfRangeException(nameof(size));
}
}
throw new PlatformNotSupportedException();
}
