Introduce VBuffer GetValues and GetIndices (#1536)

* Introduce VBuffer GetValues and GetIndices

Use the new methods in place of Count and Values/Indices in as many readonly situations as possible.

Working towards #608

Update the rest of the BinaryWriter utils to use Span.

Author: eerhardt

src/Microsoft.ML.Core/Data/VBuffer.cs

@@ -38,6 +38,23 @@ public readonly struct VBuffer<T>
         /// </summary>
         public readonly int[] Indices;
 
+        /// <summary>
+        /// The explicitly represented values.
+        /// </summary>
+        public ReadOnlySpan<T> GetValues() => Values.AsSpan(0, Count);
+
+        /// <summary>
+        /// The indices. For a dense representation, this array is not used. For a sparse representation
+        /// it is parallel to values and specifies the logical indices for the corresponding values.
+        /// </summary>
+        /// <remarks>
+        /// For example, if GetIndices() returns [3, 5] and GetValues() produces [98, 76], this VBuffer
+        /// stands for a vector with:
+        ///  - non-zeros values 98 and 76 respectively at the 4th and 6th coordinates
+        ///  - zeros at all other coordinates
+        /// </remarks>
+        public ReadOnlySpan<int> GetIndices() => IsDense ? default : Indices.AsSpan(0, Count);
+
         /// <summary>
         /// Equivalent to Count == Length.
         /// </summary>

src/Microsoft.ML.Core/Utilities/BigArray.cs

@@ -306,46 +306,45 @@ public void TrimCapacity()
         }
 
         /// <summary>
-        /// Appends the first <paramref name="length"/> elements of <paramref name="src"/> to the end.
+        /// Appends the elements of <paramref name="src"/> to the end.
         /// This method is thread safe related to calls to <see cref="M:CopyTo"/> (assuming those copy operations
         /// are happening over ranges already added), but concurrent calls to
         /// <see cref="M:AddRange"/> should not be attempted. Intended usage is that
         /// one thread will call this method, while multiple threads may access
         /// previously added ranges from <see cref="M:CopyTo"/>, concurrently with
         /// this method or themselves.
         /// </summary>
-        public void AddRange(T[] src, int length)
+        public void AddRange(ReadOnlySpan<T> src)
         {
-            Contracts.Assert(0 <= length && length <= Utils.Size(src));
-            if (length == 0)
+            if (src.IsEmpty)
                 return;
-            Contracts.AssertValue(src);
 
             int maMin;
             int miMin;
             int maMax;
             int miLim;
             LongMinToMajorMinorMin(_length, out maMin, out miMin);
-            LongLimToMajorMaxMinorLim(_length + length, out maMax, out miLim);
+            LongLimToMajorMaxMinorLim(_length + src.Length, out maMax, out miLim);
 
             Contracts.Assert(maMin <= maMax); // Could be violated if length == 0, but we already took care of this.
             Utils.EnsureSize(ref _entries, maMax + 1, BlockSize);
             switch (maMax - maMin)
             {
             case 0:
                 // Spans only one subarray, most common case and simplest implementation.
-                Contracts.Assert(miLim - miMin == length);
+                Contracts.Assert(miLim - miMin == src.Length);
                 Utils.EnsureSize(ref _entries[maMax], maMax >= FullAllocationBeyond ? BlockSize : miLim, BlockSize);
-                Array.Copy(src, 0, _entries[maMax], miMin, length);
+                src.CopyTo(_entries[maMax].AsSpan(miMin));
                 break;
             case 1:
                 // Spans two subarrays.
-                Contracts.Assert((BlockSize - miMin) + miLim == length);
+                Contracts.Assert((BlockSize - miMin) + miLim == src.Length);
                 Utils.EnsureSize(ref _entries[maMin], BlockSize, BlockSize);
-                Array.Copy(src, 0, _entries[maMin], miMin, BlockSize - miMin);
+                int firstSubArrayCapacity = BlockSize - miMin;
+                src.Slice(0, firstSubArrayCapacity).CopyTo(_entries[maMin].AsSpan(miMin));
                 Contracts.Assert(_entries[maMax] == null);
                 Utils.EnsureSize(ref _entries[maMax], maMax >= FullAllocationBeyond ? BlockSize : miLim, BlockSize);
-                Array.Copy(src, BlockSize - miMin, _entries[maMax], 0, miLim);
+                src.Slice(firstSubArrayCapacity, miLim).CopyTo(_entries[maMax]);
                 break;
             default:
                 // Spans three or more subarrays. Very rare.
@@ -354,24 +353,24 @@ public void AddRange(T[] src, int length)
                 // Copy the first segment.
                 Utils.EnsureSize(ref _entries[maMin], BlockSize, BlockSize);
                 int srcSoFar = BlockSize - miMin;
-                Array.Copy(src, 0, _entries[maMin], miMin, srcSoFar);
+                src.Slice(0, srcSoFar).CopyTo(_entries[maMin].AsSpan(miMin));
                 // Copy the internal segments.
                 for (int major = maMin + 1; major < maMax; ++major)
                 {
                     Contracts.Assert(_entries[major] == null);
                     _entries[major] = new T[BlockSize];
-                    Array.Copy(src, srcSoFar, _entries[major], 0, BlockSize);
+                    src.Slice(srcSoFar, BlockSize).CopyTo(_entries[major]);
                     srcSoFar += BlockSize;
-                    Contracts.Assert(srcSoFar < length);
+                    Contracts.Assert(srcSoFar < src.Length);
                 }
                 // Copy the last segment.
-                Contracts.Assert(length - srcSoFar == miLim);
+                Contracts.Assert(src.Length - srcSoFar == miLim);
                 Contracts.Assert(_entries[maMax] == null);
                 Utils.EnsureSize(ref _entries[maMax], maMax >= FullAllocationBeyond ? BlockSize : miLim, BlockSize);
-                Array.Copy(src, srcSoFar, _entries[maMax], 0, miLim);
+                src.Slice(srcSoFar, miLim).CopyTo(_entries[maMax]);
                 break;
             }
-            _length += length;
+            _length += src.Length;
         }
 
         /// <summary>