Merge pull request #85 from Sergio0694/feature_memory-4-5-1

System.Memory updated to 4.5.1

Author: Sergio0694

NeuralNetwork.NET/APIs/DatasetLoader.cs

@@ -9,8 +9,8 @@
 using NeuralNetworkNET.SupervisedLearning.Data;
 using NeuralNetworkNET.SupervisedLearning.Parameters;
 using NeuralNetworkNET.SupervisedLearning.Progress;
-using SixLabors.ImageSharp;
 using SixLabors.ImageSharp.PixelFormats;
+using SixLabors.ImageSharp.Processing;
 
 namespace NeuralNetworkNET.APIs
 {

NeuralNetwork.NET/APIs/Datasets/Cifar10.cs

@@ -150,7 +150,7 @@ private static unsafe void ExportSamples([NotNull] DirectoryInfo folder, (string
                         int label = stream.ReadByte();
                         stream.Read(temp, 0, SampleSize);
                         using (Image<Rgb24> image = new Image<Rgb24>(32, 32))
-                        fixed (Rgb24* p0 = &image.DangerousGetPinnableReferenceToPixelBuffer())
+                        fixed (Rgb24* p0 = image.GetPixelSpan())
                         {
                             for (int j = 0; j < ImageSize; j++)
                                 p0[j] = new Rgb24(ptemp[j], ptemp[j + ImageSize], ptemp[j + 2 * ImageSize]);

NeuralNetwork.NET/APIs/Datasets/Cifar100.cs

@@ -188,7 +188,7 @@ private static unsafe void ExportSamples([NotNull] DirectoryInfo folder, (string
                             fine = stream.ReadByte();
                         stream.Read(temp, 0, SampleSize);
                         using (Image<Rgb24> image = new Image<Rgb24>(32, 32))
-                            fixed (Rgb24* p0 = &image.DangerousGetPinnableReferenceToPixelBuffer())
+                            fixed (Rgb24* p0 = image.GetPixelSpan())
                             {
                                 for (int j = 0; j < ImageSize; j++)
                                     p0[j] = new Rgb24(ptemp[j], ptemp[j + ImageSize], ptemp[j + 2 * ImageSize]);

NeuralNetwork.NET/APIs/Datasets/Mnist.cs

@@ -172,7 +172,7 @@ private static unsafe void ExportSamples([NotNull] DirectoryInfo folder, (string
                         xGzip.Read(temp, 0, SampleSize);
                         int label = yGzip.ReadByte();
                         using (Image<Rgb24> image = new Image<Rgb24>(28, 28))
-                            fixed (Rgb24* p0 = &image.DangerousGetPinnableReferenceToPixelBuffer())
+                            fixed (Rgb24* p0 = image.GetPixelSpan())
                             {
                                 for (int j = 0; j < SampleSize; j++)
                                     p0[j] = new Rgb24(ptemp[j], ptemp[j], ptemp[j]);

NeuralNetwork.NET/APIs/Structs/DatasetSample.cs

@@ -10,14 +10,14 @@ public readonly ref struct DatasetSample
         /// <summary>
         /// Gets the <see cref="Span{T}"/> referencing the current sample inputs
         /// </summary>
-        public Span<float> X { get; }
+        public ReadOnlySpan<float> X { get; }
 
         /// <summary>
         /// Gets the <see cref="Span{T}"/> referencing the current sample expected outputs
         /// </summary>
-        public Span<float> Y { get; }
+        public ReadOnlySpan<float> Y { get; }
 
-        internal DatasetSample(Span<float> x, Span<float> y)
+        internal DatasetSample(ReadOnlySpan<float> x, ReadOnlySpan<float> y)
         {
             X = x;
             Y = y;

NeuralNetwork.NET/APIs/Structs/Tensor.cs

@@ -281,7 +281,8 @@ public unsafe float[] ToArray(bool keepAlive = true)
         {
             if (Ptr == IntPtr.Zero) return new float[0, 0];
             float[,] result = new float[Entities, Length];
-            new Span<float>(this, Size).CopyTo(result.AsSpan());
+            fixed (float* p = result)
+                new Span<float>(this, Size).CopyTo(new Span<float>(p, Size));
             if (!keepAlive) Free();
             return result;
         }

NeuralNetwork.NET/Extensions/ArrayExtensions.cs

@@ -11,24 +11,43 @@ namespace NeuralNetworkNET.Extensions
     /// </summary>
     internal static class ArrayExtensions
     {
+        /// <summary>
+        /// Flattens a 2D array to a 1D array
+        /// </summary>
+        /// <typeparam name="T">The type of each element in the input matrix</typeparam>
+        /// <param name="m">The input 2D array to flatten</param>
+        [Pure]
+        [CollectionAccess(CollectionAccessType.Read)]
+        public static unsafe T[] Flatten<T>([NotNull] this T[,] m) where T : unmanaged
+        {
+            fixed (T* p = m) return new Span<T>(p, m.Length).ToArray();
+        }
+
         /// <summary>
         /// Merges the line pairs in the input collection into two 2D arrays
         /// </summary>
         /// <typeparam name="T">The type of each element in the input lines</typeparam>
         /// <param name="lines">The lines to merge</param>
         [Pure]
         [CollectionAccess(CollectionAccessType.Read)]
-        public static (T[,], T[,]) MergeLines<T>(this IEnumerable<(T[], T[])> lines) where T : struct
+        public static unsafe (T[,], T[,]) MergeLines<T>(this IEnumerable<(T[], T[])> lines) where T : unmanaged
         {
             (T[] X, T[] Y)[] set = lines.ToArray();
             T[,] 
                 x = new T[set.Length, set[0].X.Length],
                 y = new T[set.Length, set[0].Y.Length];
-            Parallel.For(0, set.Length, i =>
+            int
+                wx = x.GetLength(1),
+                wy = y.GetLength(1);
+            fixed (T* px0 = x, py0 = y)
             {
-                set[i].X.AsSpan().CopyTo(x.Slice(i));
-                set[i].Y.AsSpan().CopyTo(y.Slice(i));
-            }).AssertCompleted();
+                T* px = px0, py = py0;
+                Parallel.For(0, set.Length, i =>
+                {
+                    set[i].X.AsSpan().CopyTo(new Span<T>(px + i * wx, wx));
+                    set[i].Y.AsSpan().CopyTo(new Span<T>(py + i * wy, wy));
+                }).AssertCompleted();
+            }
             return (x, y);
         }
     }

NeuralNetwork.NET/Extensions/DebugExtensions.cs

@@ -19,7 +19,7 @@ internal static class DebugExtensions
         public static unsafe bool ContentEquals(this Span<float> x1, Span<float> x2, float absolute = 1e-6f, float relative = 1e-6f)
         {
             if (x1.Length != x2.Length) return false;
-            fixed (float* p1 = &x1.DangerousGetPinnableReference(), p2 = &x2.DangerousGetPinnableReference())
+            fixed (float* p1 = x1, p2 = x2)
             {
                 for (int i = 0; i < x1.Length; i++)
                     if (!p1[i].EqualsWithDelta(p2[i], absolute, relative))
@@ -55,13 +55,14 @@ public static bool ContentEquals(in this Tensor m, in Tensor o, float absolute =
         /// <param name="o">The second matrix to test</param>
         /// <param name="absolute">The relative comparison threshold</param>
         /// <param name="relative">The relative comparison threshold</param>
-        public static bool ContentEquals([CanBeNull] this float[,] m, [CanBeNull] float[,] o, float absolute = 1e-6f, float relative = 1e-6f)
+        public static unsafe bool ContentEquals([CanBeNull] this float[,] m, [CanBeNull] float[,] o, float absolute = 1e-6f, float relative = 1e-6f)
         {
             if (m == null && o == null) return true;
             if (m == null || o == null) return false;
             if (m.GetLength(0) != o.GetLength(0) ||
                 m.GetLength(1) != o.GetLength(1)) return false;
-            return m.AsSpan().ContentEquals(o.AsSpan(), absolute, relative);
+            fixed (float* pm = m, po = o)
+                return new Span<float>(pm, m.Length).ContentEquals(new Span<float>(po, o.Length), absolute, relative);
         }
 
         /// <summary>

NeuralNetwork.NET/Extensions/SpanExtensions.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 
@@ -17,29 +16,27 @@ public static class SpanExtensions
         /// </summary>
         /// <param name="span">The <see cref="Span{T}"/> to fill up</param>
         /// <param name="provider">The values provider to use</param>
-        public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider) where T : struct
+        public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider) where T : unmanaged
         {
             // Fill in parallel
             int
                 cores = Environment.ProcessorCount,
                 batch = span.Length / cores,
-                mod = span.Length % cores,
-                size = Unsafe.SizeOf<T>();
-            ref T r0 = ref span.DangerousGetPinnableReference();
-            fixed (byte* p0 = &Unsafe.As<T, byte>(ref r0))
+                mod = span.Length % cores;
+            fixed (T* p0 = span)
             {
-                byte* pc = p0;
+                T* pc = p0;
                 Parallel.For(0, cores, i =>
                 {
-                    byte* p = pc + i * batch * size;
-                    for (int j = 0; j < batch; j++, p += size)
-                        Unsafe.Write(p, provider());
+                    T* p = pc + i * batch;
+                    for (int j = 0; j < batch; j++)
+                        p[j] = provider();
                 }).AssertCompleted();
 
                 // Remaining values
                 if (mod < 1) return;
                 for (int i = span.Length - mod; i < span.Length; i++)
-                    Unsafe.Write(pc + i * size, provider());
+                    pc[i] = provider();
             }
         }
 
@@ -51,11 +48,12 @@ public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider)
         /// <param name="w">The number of matrix columns</param>
         [Pure, NotNull]
         [CollectionAccess(CollectionAccessType.Read)]
-        public static T[,] AsMatrix<T>(this Span<T> span, int h, int w) where T : struct
+        public static unsafe T[,] AsMatrix<T>(this Span<T> span, int h, int w) where T : unmanaged
         {
             if (h * w != span.Length) throw new ArgumentException("The input dimensions don't match the source vector size");
             T[,] m = new T[h, w];
-            span.CopyTo(m.AsSpan());
+            fixed (void* p = m)
+                span.CopyTo(new Span<T>(p, m.Length));
             return m;
         }
 
@@ -65,55 +63,32 @@ public static unsafe void Fill<T>(this Span<T> span, [NotNull] Func<T> provider)
         /// <typeparam name="T">The type of each value in the input <see cref="Span{T}"/></typeparam>
         /// <param name="span">The input <see cref="Span{T}"/> to read</param>
         [Pure]
-        public static unsafe int GetContentHashCode<T>(this Span<T> span) where T : struct
+        public static unsafe int GetContentHashCode<T>(this Span<T> span) where T : unmanaged
         {
-            fixed (byte* p0 = &Unsafe.As<T, byte>(ref span.DangerousGetPinnableReference()))
+            fixed (T* p0 = span)
             {
-                int size = Unsafe.SizeOf<T>();
                 int hash = 17;
                 unchecked
                 {
                     for (int i = 0; i < span.Length; i++)
-                        hash = hash * 23 + Unsafe.Read<T>(p0 + size * i).GetHashCode();
+                        hash = hash * 23 + p0[i].GetHashCode();
                     return hash;
                 }
             }
         }
 
-        /// <summary>
-        /// Returns a deep copy of the input <see cref="Span{T}"/>
-        /// </summary>
-        /// <param name="span">The <see cref="Span{T}"/> to clone</param>
-        /// <remarks>This method avoids the boxing of the <see cref="Array.Clone"/> method, and it is faster thanks to the use of the methods in the <see cref="Buffer"/> class</remarks>
-        [Pure]
-        [CollectionAccess(CollectionAccessType.Read)]
-        public static T[] Copy<T>(this Span<T> span) where T : struct
-        {
-            T[] result = new T[span.Length];
-            span.CopyTo(result);
-            return result;
-        }
-
-        /// <summary>
-        /// Returns a new <see cref="Span{T}"/> instance from the input matrix
-        /// </summary>
-        /// <typeparam name="T">The type of the input matrix</typeparam>
-        /// <param name="m">The input matrix</param>
-        [Pure]
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static Span<T> AsSpan<T>([NotNull] this T[,] m) where T : struct => Span<T>.DangerousCreate(m, ref m[0, 0], m.Length);
-
         /// <summary>
         /// Extracts a single row from a given matrix
         /// </summary>
         /// <param name="m">The source matrix</param>
         /// <param name="row">The target row to return</param>
-        [Pure]
+        [Pure, NotNull]
         [CollectionAccess(CollectionAccessType.Read)]
-        public static Span<T> Slice<T>([NotNull] this T[,] m, int row) where T : struct
+        public static unsafe T[] Slice<T>([NotNull] this T[,] m, int row) where T : unmanaged
         {
             if (row < 0 || row > m.GetLength(0) - 1) throw new ArgumentOutOfRangeException(nameof(row), "The row index isn't valid");
-            return Span<T>.DangerousCreate(m, ref m[row, 0], m.GetLength(1));
+            int wm = m.GetLength(1);
+            fixed (T* p = m) return new Span<T>(p + row * wm, wm).ToArray();
         }
 
         #endregion
@@ -131,7 +106,7 @@ public static unsafe int Argmax(this Span<float> span)
             if (span.Length < 2) return default;
             int index = 0;
             float max = float.MinValue;
-            fixed (float* p = &span.DangerousGetPinnableReference())
+            fixed (float* p = span)
             {
                 for (int j = 0; j < span.Length; j++)
                 {
@@ -158,7 +133,7 @@ public static unsafe int Argmax(this Span<float> span)
         internal static unsafe bool MatchElementwiseThreshold(this Span<float> x1, Span<float> x2, float threshold)
         {
             if (x1.Length != x2.Length) throw new ArgumentException("The two input spans must have the same length");
-            fixed (float* px1 = &x1.DangerousGetPinnableReference(), px2 = &x2.DangerousGetPinnableReference())
+            fixed (float* px1 = x1, px2 = x2)
                 for (int i = 0; i < x1.Length; i++)
                     if (px1[i] > threshold != px2[i] > threshold)
                         return false;
@@ -177,7 +152,7 @@ internal static unsafe bool MatchElementwiseThreshold(this Span<float> x1, Span<
         internal static unsafe bool IsCloseTo(this Span<float> x1, Span<float> x2, float threshold)
         {
             if (x1.Length != x2.Length) throw new ArgumentException("The two input spans must have the same length");
-            fixed (float* px1 = &x1.DangerousGetPinnableReference(), px2 = &x2.DangerousGetPinnableReference())
+            fixed (float* px1 = x1, px2 = x2)
                 for (int i = 0; i < x1.Length; i++)
                     if ((px1[i] - px2[i]).Abs() > threshold)
                         return false;

NeuralNetwork.NET/Extensions/StreamExtensions.cs

@@ -16,7 +16,7 @@ internal static class StreamExtensions
         /// <typeparam name="T">The <see langword="struct"/> type to serialize</typeparam>
         /// <param name="stream">The target <see cref="Stream"/> to use to write the data</param>
         /// <param name="value">The <see langword="struct"/> to write to the <see cref="Stream"/> instance</param>
-        public static unsafe void Write<T>([NotNull] this Stream stream, T value) where T : struct
+        public static unsafe void Write<T>([NotNull] this Stream stream, T value) where T : unmanaged
         {
             byte[] bytes = new byte[Unsafe.SizeOf<T>()];
             fixed (void* p = bytes) Unsafe.Copy(p, ref value);
@@ -30,7 +30,7 @@ public static unsafe void Write<T>([NotNull] this Stream stream, T value) where
         /// <param name="stream">The source <see cref="Stream"/> instance to use to read the data</param>
         /// <param name="value">The resulting <typeparamref name="T"/> value that is read from the <see cref="Stream"/></param>
         [MustUseReturnValue]
-        public static unsafe bool TryRead<T>([NotNull] this Stream stream, out T value) where T : struct
+        public static unsafe bool TryRead<T>([NotNull] this Stream stream, out T value) where T : unmanaged
         {
             byte[] bytes = new byte[Unsafe.SizeOf<T>()];
             value = default;