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); } }