using System; using Hast.Common.Numerics; using Hast.Transformer.Abstractions.SimpleMemory; namespace Hast.Samples.SampleAssembly { public enum SimdOperation { Add, Subtract, Multiply, Divide } /// /// Sample to showcase SIMD (Simple Instruction Multiple Data) processing usage, i.e. operations executed in parallel /// on multiple elements of vectors. /// /// /// System.Numerics.Vectors (including the NuGet package version of it: http://www.nuget.org/packages/System.Numerics.Vectors) /// could be used for SIMD processing on x64 systems. However Vector can only contain that many elements that can /// fit into the processor's SIMD register and thus is quite inconvenient to use. So using a custom implementation. /// public class SimdCalculator { public const int VectorsElementCountInt32Index = 0; public const int VectorElementsStartInt32Index = 1; public const int ResultVectorElementsStartInt32Index = 1; // This needs to be this low to fit all operations on the Nexys 4 DDR board's FPGA. On the same board just // transforming AddVectors or SubtractVectors could fit with a degree of parallelism of more than 500. public const int MaxDegreeOfParallelism = 30; public virtual void AddVectors(SimpleMemory memory) { RunSimdOperation(memory, SimdOperation.Add); } public virtual void SubtractVectors(SimpleMemory memory) { RunSimdOperation(memory, SimdOperation.Subtract); } public virtual void MultiplyVectors(SimpleMemory memory) { RunSimdOperation(memory, SimdOperation.Multiply); } public virtual void DivideVectors(SimpleMemory memory) { RunSimdOperation(memory, SimdOperation.Divide); } private void RunSimdOperation(SimpleMemory memory, SimdOperation operation) { var elementCount = memory.ReadInt32(VectorsElementCountInt32Index); int i = 0; while (i < elementCount) { var vector1 = new int[MaxDegreeOfParallelism]; var vector2 = new int[MaxDegreeOfParallelism]; var resultVector = new int[MaxDegreeOfParallelism]; for (int m = 0; m < MaxDegreeOfParallelism; m++) { vector1[m] = memory.ReadInt32(VectorElementsStartInt32Index + i + m); } for (int m = 0; m < MaxDegreeOfParallelism; m++) { vector2[m] = memory.ReadInt32(VectorElementsStartInt32Index + i + m + elementCount); } switch (operation) { case SimdOperation.Add: resultVector = SimdOperations.AddVectors(vector1, vector2, MaxDegreeOfParallelism); break; case SimdOperation.Subtract: resultVector = SimdOperations.SubtractVectors(vector1, vector2, MaxDegreeOfParallelism); break; case SimdOperation.Multiply: resultVector = SimdOperations.MultiplyVectors(vector1, vector2, MaxDegreeOfParallelism); break; case SimdOperation.Divide: resultVector = SimdOperations.DivideVectors(vector1, vector2, MaxDegreeOfParallelism); break; default: break; } for (int m = 0; m < MaxDegreeOfParallelism; m++) { memory.WriteInt32(ResultVectorElementsStartInt32Index + i + m, resultVector[m]); } i += MaxDegreeOfParallelism; } } } public static class SimdCalculatorExtensions { public static int[] AddVectors(this SimdCalculator simdCalculator, int[] vector1, int[] vector2) { return RunSimdOperation(vector1, vector2, memory => simdCalculator.AddVectors(memory)); } public static int[] SubtractVectors(this SimdCalculator simdCalculator, int[] vector1, int[] vector2) { return RunSimdOperation(vector1, vector2, memory => simdCalculator.SubtractVectors(memory)); } public static int[] MultiplyVectors(this SimdCalculator simdCalculator, int[] vector1, int[] vector2) { return RunSimdOperation(vector1, vector2, memory => simdCalculator.MultiplyVectors(memory)); } public static int[] DivideVectors(this SimdCalculator simdCalculator, int[] vector1, int[] vector2) { return RunSimdOperation(vector1, vector2, memory => simdCalculator.DivideVectors(memory)); } private static int[] RunSimdOperation(int[] vector1, int[] vector2, Action operation) { SimdOperations.ThrowIfVectorsNotEquallyLong(vector1, vector2); var originalElementCount = vector1.Length; vector1 = vector1.PadToMultipleOf(SimdCalculator.MaxDegreeOfParallelism); vector2 = vector2.PadToMultipleOf(SimdCalculator.MaxDegreeOfParallelism); var elementCount = vector1.Length; var memory = new SimpleMemory(1 + elementCount * 2); memory.WriteInt32(SimdCalculator.VectorsElementCountInt32Index, elementCount); for (int i = 0; i < elementCount; i++) { memory.WriteInt32(SimdCalculator.VectorElementsStartInt32Index + i, vector1[i]); memory.WriteInt32(SimdCalculator.VectorElementsStartInt32Index + elementCount + i, vector2[i]); } operation(memory); var result = new int[elementCount]; for (int i = 0; i < elementCount; i++) { result[i] = memory.ReadInt32(SimdCalculator.ResultVectorElementsStartInt32Index + i); } return result.CutToLength(originalElementCount); } } }