Added System.Reflection.Emit.Lightweight via Nuget to have DynamicMethod available in NETSTandard2.0 as well. Guarded the use of ILEmit with a runtime check and fallback to regular reflection for AOT platforms. Removed software fallbacks that skip Span creation to simplify code, with the ILEmit there is no performance penalty for using Span and the SIMDVectorOperations have a fallback as well. Some code cleanup.

SebastianDirks · SebastianDirks · commit b4d2f163f36f · 2023-07-05T12:24:55.000+02:00
diff --git a/Benchmarks/VectorTransformBenchmark.cs b/Benchmarks/VectorTransformBenchmark.cs
@@ -389,7 +389,7 @@ public AxisAlignedBox2D BoundsSpanSIMDVector()
 
             if (dims == 2 && coordinates.Count >= Vector<float>.Count)
             {
-                var coordSpan = vectorBlock.RawCoordinates().AsSpan();
+                var coordSpan = coordinates.AsSpan();
                 var vecSpan = MemoryMarshal.Cast<float, Vector<float>>(coordSpan);
                 int chunkSize = Vector<float>.Count;
 
@@ -417,7 +417,7 @@ public AxisAlignedBox2D BoundsSpanSIMDVector()
                     bounds.YMax = Math.Max(bounds.YMax, maxVector[i + 1]);
                 }
             }
-            else if(coordinates.Count >= 24) { 
+            else if(coordinates.Count >= Vector<float>.Count * 3) { 
                 var coordSpan = vectorBlock.RawCoordinates().AsSpan();
                 var vecSpan = MemoryMarshal.Cast<float, Vector<float>>(coordSpan);
                 //var vecSpanShifted = MemoryMarshal.Cast<float, Vector<float>>(coordSpan.Slice(1));
@@ -787,7 +787,7 @@ public static void Main(string[] args)
             debugVec3Rot();
             debugVec2Bounds();
             debugVec3Bounds();
-            Type[] benchmarks = { typeof(VectorTranslate) };//typeof(VectorBlockBounds) };//, typeof(VectorTranslate), typeof(VectorRotate) };
+            Type[] benchmarks = { typeof(VectorBlockBounds) };//typeof(VectorBlockBounds) };//, typeof(VectorTranslate), typeof(VectorRotate) };
             var summary = BenchmarkRunner.Run(benchmarks);
         }
 
diff --git a/ReaderWriter/OVFDefinition/OVFDefinition.csproj b/ReaderWriter/OVFDefinition/OVFDefinition.csproj
@@ -28,6 +28,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="System.Reflection.Emit.Lightweight" Version="4.7.0" />
 
 	  <Protobuf Include="../../submodules/OpenVectorFormat/build_processor_strategy.proto" />
 	  <Protobuf Include="../../submodules/OpenVectorFormat/open_vector_format.proto" />
diff --git a/ReaderWriter/OVFDefinition/ProtoUtils.cs b/ReaderWriter/OVFDefinition/ProtoUtils.cs
@@ -37,15 +37,19 @@ You should have received a copy of the GNU Lesser General Public
 namespace OpenVectorFormat.Utils
 {
     /// <summary>
-    /// Class to hold general, usefull utilites for working with protobuf messages.
+    /// Class to hold general, useful utilities for working with protobuf messages.
     /// </summary>
     public static class ProtoUtils
     {
         //this fieldInfo to access private fields of repeatedField<float> is only calculated once
         private static readonly FieldInfo repFieldPrivateArrayFieldInfo = typeof(RepeatedField<float>).GetField("array", BindingFlags.NonPublic | BindingFlags.Instance);
 
+        private static readonly Func<RepeatedField<float>, float[]> repFieldArrayDynamicGetter =
 #if NETCOREAPP3_0_OR_GREATER
-        private static readonly Func<RepeatedField<float>, float[]> repFieldArrayDynamicGetter = CreateGetter<RepeatedField<float>, float[]>(repFieldPrivateArrayFieldInfo);
+            !System.Runtime.CompilerServices.RuntimeFeature.IsDynamicCodeSupported ?
+            ReflectGetter :
+#endif
+            CreateGetter<RepeatedField<float>, float[]>(repFieldPrivateArrayFieldInfo);
 
         private static Func<S, T> CreateGetter<S, T>(FieldInfo field)
         {
@@ -64,7 +68,11 @@ private static Func<S, T> CreateGetter<S, T>(FieldInfo field)
             gen.Emit(OpCodes.Ret);
             return (Func<S, T>)getterMethod.CreateDelegate(typeof(Func<S, T>));
         }
-#endif
+
+        private static float[] ReflectGetter(RepeatedField<float> field)
+        {
+            return (float[])repFieldPrivateArrayFieldInfo.GetValue(field);
+        }
 
         /// <summary>
         /// Creates a copy of a protobuf message with some fields excluded.
@@ -141,16 +149,11 @@ public static Span<T> AsSpan<T>(this RepeatedField<T> repeatedField)
         /// It is not safe to add or remove to and from the repeated field while using the Span,
         /// since this might allocate a new private array.
         /// </summary>
-        /// <typeparam name="T"></typeparam>
         /// <param name="repeatedField"></param>
         /// <returns></returns>
         public static Span<float> AsSpan(this RepeatedField<float> repeatedField)
         {
-#if NETCOREAPP3_0_OR_GREATER
             var privateArray = repFieldArrayDynamicGetter(repeatedField);
-#else
-            var privateArray = (float[]) repFieldPrivateArrayFieldInfo.GetValue(repeatedField);
-#endif
             return privateArray.AsSpan().Slice(0, repeatedField.Count);
         }
     }
diff --git a/ReaderWriter/OVFDefinition/SIMDVectorOperations.cs b/ReaderWriter/OVFDefinition/SIMDVectorOperations.cs
@@ -23,16 +23,12 @@ You should have received a copy of the GNU Lesser General Public
 */
 
 using System;
-using System.Collections.Generic;
 using System.Numerics;
 using System.Runtime.InteropServices;
 #if NETCOREAPP3_0_OR_GREATER
 using System.Runtime.Intrinsics.X86;
 using System.Runtime.Intrinsics;
 #endif
-using System.Text;
-using System.Transactions;
-using System.Threading;
 
 namespace OpenVectorFormat
 {
diff --git a/ReaderWriter/OVFDefinition/VectorBlockExtensions.cs b/ReaderWriter/OVFDefinition/VectorBlockExtensions.cs
@@ -28,12 +28,6 @@ You should have received a copy of the GNU Lesser General Public
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
-using System.Runtime.InteropServices;
-#if NETCOREAPP3_0_OR_GREATER
-using System.Runtime.Intrinsics;
-using System.Runtime.Intrinsics.X86;
-#endif
-using System.Transactions;
 using static OpenVectorFormat.SIMDVectorOperations;
 
 namespace OpenVectorFormat
@@ -442,67 +436,21 @@ public static RepeatedField<float> RawCoordinates(this VectorBlock vectorBlock)
             }
         }
 
-#if NETCOREAPP3_0_OR_GREATER
-        [StructLayout(LayoutKind.Sequential, Pack = 4)]
-        private struct Vec256FromVec3
-        {
-            public Vector256<float> vec256;
-            private float unused;
-        }
-#endif
-
         private static void RotateVector2(RepeatedField<float> coordinates, float angleRad, int dims)
         {
-            if (coordinates.Count % dims != 0) throw new ArgumentException($"coordinates count is {coordinates.Count} but must be a multiple of {dims}");
-
-#if NETCOREAPP3_0_OR_GREATER
-            if (Avx2.IsSupported & coordinates.Count > 80 * dims)
-            {
-                var coordSpan = ProtoUtils.AsSpan<float>(coordinates);
-                RotateAsVector2(coordSpan, angleRad, dims);
-                return;
-            }
-#endif
-
-            var sin = (float)Math.Sin(angleRad);
-            var cos = (float)Math.Cos(angleRad);
-            var nsin = -sin;
-
-            for (int i = 0; i < coordinates.Count - 1; i += dims)
-            {
-                float xNew = coordinates[i] * cos + coordinates[i + 1] * nsin;
-                float yNew = coordinates[i] * sin + coordinates[i + 1] * cos;
-                coordinates[i] = xNew; coordinates[i + 1] = yNew;
-            }
+            var coordSpan = coordinates.AsSpan();
+            RotateAsVector2(coordSpan, angleRad, dims);
         }
 
         private static AxisAlignedBox2D Bounds2DFromCoordinates(RepeatedField<float> coordinates, int dims)
         {
             if (coordinates.Count == 0)
                 return AxisAlignedBox2DExtensions.EmptyAAB2D();
-            else if (coordinates.Count > 100 * dims)
+            else
             {
                 var coordSpan = coordinates.AsSpan();
                 return SIMDVectorOperations.Bounds2D(coordSpan, dims);
             }
-            else
-            {
-                var bounds = new AxisAlignedBox2D()
-                {
-                    XMin = coordinates[0],
-                    YMin = coordinates[1],
-                    XMax = coordinates[0],
-                    YMax = coordinates[1],
-                };
-                for (int i = dims; i < coordinates.Count - 1; i += dims)
-                {
-                    if (coordinates[i] < bounds.XMin) bounds.XMin = coordinates[i];
-                    if (coordinates[i + 1] < bounds.YMin) bounds.YMin = coordinates[i + 1];
-                    if (coordinates[i] > bounds.XMax) bounds.XMax = coordinates[i];
-                    if (coordinates[i + 1] > bounds.YMax) bounds.YMax = coordinates[i + 1];
-                }
-                return bounds;
-            }
         }
 
         /// <summary>
@@ -514,7 +462,6 @@ private static AxisAlignedBox2D Bounds2DFromCoordinates(RepeatedField<float> coo
         /// <returns></returns>
         public static List<Vector2> ToVector2(this VectorBlock vectorBlock)
         {
-            var list = new List<Vector2>();
             switch (vectorBlock.VectorDataCase)
             {
                 case VectorBlock.VectorDataOneofCase.LineSequence:
@@ -556,7 +503,6 @@ public static List<Vector2> ToVector2(this VectorBlock vectorBlock)
         /// <returns></returns>
         public static List<Vector3> ToVector3(this VectorBlock vectorBlock)
         {
-            var list = new List<Vector2>();
             switch (vectorBlock.VectorDataCase)
             {
                 case VectorBlock.VectorDataOneofCase.LineSequence:

Original file line number	Diff line number	Diff line change
`@@ -389,7 +389,7 @@ public AxisAlignedBox2D BoundsSpanSIMDVector()`
`389`	`389`
`390`	`390`	`if (dims == 2 && coordinates.Count >= Vector<float>.Count)`
`391`	`391`	`{`
`392`		`- var coordSpan = vectorBlock.RawCoordinates().AsSpan();`
	`392`	`+ var coordSpan = coordinates.AsSpan();`
`393`	`393`	`var vecSpan = MemoryMarshal.Cast<float, Vector<float>>(coordSpan);`
`394`	`394`	`int chunkSize = Vector<float>.Count;`
`395`	`395`
`@@ -417,7 +417,7 @@ public AxisAlignedBox2D BoundsSpanSIMDVector()`
`417`	`417`	`bounds.YMax = Math.Max(bounds.YMax, maxVector[i + 1]);`
`418`	`418`	`}`
`419`	`419`	`}`
`420`		`- else if(coordinates.Count >= 24) {`
	`420`	`+ else if(coordinates.Count >= Vector<float>.Count * 3) {`
`421`	`421`	`var coordSpan = vectorBlock.RawCoordinates().AsSpan();`
`422`	`422`	`var vecSpan = MemoryMarshal.Cast<float, Vector<float>>(coordSpan);`
`423`	`423`	`//var vecSpanShifted = MemoryMarshal.Cast<float, Vector<float>>(coordSpan.Slice(1));`
`@@ -787,7 +787,7 @@ public static void Main(string[] args)`
`787`	`787`	`debugVec3Rot();`
`788`	`788`	`debugVec2Bounds();`
`789`	`789`	`debugVec3Bounds();`
`790`		`- Type[] benchmarks = { typeof(VectorTranslate) };//typeof(VectorBlockBounds) };//, typeof(VectorTranslate), typeof(VectorRotate) };`
	`790`	`+ Type[] benchmarks = { typeof(VectorBlockBounds) };//typeof(VectorBlockBounds) };//, typeof(VectorTranslate), typeof(VectorRotate) };`
`791`	`791`	`var summary = BenchmarkRunner.Run(benchmarks);`
`792`	`792`	`}`
`793`	`793`