Respond to PR feedback.

eerhardt · eerhardt · commit 0a9747b2eae6 · 2018-11-15T07:38:40.000-06:00
diff --git a/src/Microsoft.ML.Core/Data/MetadataUtils.cs b/src/Microsoft.ML.Core/Data/MetadataUtils.cs
@@ -319,8 +319,7 @@ public static void GetSlotNames(RoleMappedSchema schema, RoleMappedSchema.Column
             IReadOnlyList<ColumnInfo> list;
             if ((list = schema?.GetColumns(role)) == null || list.Count != 1 || !schema.Schema.HasSlotNames(list[0].Index, vectorSize))
             {
-                slotNames = VBufferMutationContext.Create(ref slotNames, vectorSize, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref slotNames, vectorSize, 0);
             }
             else
                 schema.Schema.GetMetadata(Kinds.SlotNames, list[0].Index, ref slotNames);
diff --git a/src/Microsoft.ML.Core/Data/VBufferMutationContext.cs b/src/Microsoft.ML.Core/Data/VBufferMutationContext.cs
@@ -132,7 +132,9 @@ internal VBufferMutationContext(int logicalLength,
         /// with a larger physical value count than was needed
         /// because the final value count was not known at creation time.
         /// </param>
-        /// <returns></returns>
+        /// <returns>
+        /// The newly created <see cref="VBuffer{T}"/>.
+        /// </returns>
         public VBuffer<T> CreateBuffer(int? physicalValuesCount = null)
         {
             int count = Values.Length;
diff --git a/src/Microsoft.ML.Core/Utilities/Utils.cs b/src/Microsoft.ML.Core/Utilities/Utils.cs
@@ -1114,9 +1114,7 @@ public static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource
             for (int i = 0; i < source.Length; i++)
             {
                 if (predicate(source[i]))
-                {
                     result++;
-                }
             }
             return result;
         }
@@ -1128,9 +1126,7 @@ public static bool All<TSource>(this ReadOnlySpan<TSource> source, Func<TSource,
             for (int i = 0; i < source.Length; i++)
             {
                 if (!predicate(source[i]))
-                {
                     return false;
-                }
             }
             return true;
         }
diff --git a/src/Microsoft.ML.Core/Utilities/VBufferUtils.cs b/src/Microsoft.ML.Core/Utilities/VBufferUtils.cs
@@ -314,10 +314,7 @@ public static void ForEachEitherDefined<T>(in VBuffer<T> a, in VBuffer<T> b, Act
         /// </summary>
         public static void Clear<T>(ref VBuffer<T> dst)
         {
-            int dstValuesCount = dst.GetValues().Length;
-            if (dstValuesCount == 0)
-                return;
-            var mutation = VBufferMutationContext.Create(ref dst, dst.Length, dstValuesCount);
+            var mutation = VBufferMutationContext.CreateFromBuffer(ref dst);
             mutation.Values.Clear();
         }
 
@@ -346,8 +343,7 @@ public static void Apply<T>(ref VBuffer<T> dst, SlotValueManipulator<T> manip)
         {
             Contracts.CheckValue(manip, nameof(manip));
 
-            int dstValuesCount = dst.GetValues().Length;
-            var mutation = VBufferMutationContext.Create(ref dst, dst.Length, dstValuesCount);
+            var mutation = VBufferMutationContext.CreateFromBuffer(ref dst);
             if (dst.IsDense)
             {
                 for (int i = 0; i < mutation.Values.Length; i++)
@@ -381,8 +377,8 @@ public static void ApplyAt<T>(ref VBuffer<T> dst, int slot, SlotValueManipulator
             Contracts.CheckValue(manip, nameof(manip));
             Contracts.CheckValueOrNull(pred);
 
-            int dstValuesCount = dst.GetValues().Length;
-            var mutation = VBufferMutationContext.Create(ref dst, dst.Length, dstValuesCount);
+            var mutation = VBufferMutationContext.CreateFromBuffer(ref dst);
+            int dstValuesCount = mutation.Values.Length;
             if (dst.IsDense)
             {
                 // The vector is dense, so we can just do a direct access.
@@ -963,8 +959,7 @@ private static void ApplyWithCoreCopy<TSrc, TDst>(in VBuffer<TSrc> src, ref VBuf
             {
                 if (srcValues.Length == 0)
                 {
-                    res = VBufferMutationContext.Create(ref res, length, 0)
-                        .CreateBuffer();
+                    Resize(ref res, length, 0);
                 }
                 else if (src.IsDense)
                 {
@@ -1209,8 +1204,7 @@ public static void ApplyIntoEitherDefined<TSrc, TDst>(in VBuffer<TSrc> src, ref
             // equal lengths, but I don't care here.
             if (srcValues.Length == 0)
             {
-                dst = VBufferMutationContext.Create(ref dst, src.Length, 0)
-                    .CreateBuffer();
+                Resize(ref dst, src.Length, 0);
                 return;
             }
             var mutation = VBufferMutationContext.Create(ref dst,
@@ -1263,8 +1257,7 @@ public static void ApplyInto<TSrc1, TSrc2, TDst>(in VBuffer<TSrc1> a, in VBuffer
             if (aValues.Length == 0 && bValues.Length == 0)
             {
                 // Case 1. Output will be empty.
-                dst = VBufferMutationContext.Create(ref dst, a.Length, 0)
-                    .CreateBuffer();
+                Resize(ref dst, a.Length, 0);
                 return;
             }
 
@@ -1441,5 +1434,15 @@ public static void Copy<T>(List<T> src, ref VBuffer<T> dst, int length)
             }
             dst = mutation.CreateBuffer();
         }
+
+        /// <summary>
+        /// Updates the logical length and number of physical values to be represented in
+        /// <paramref name="dst"/>, while preserving the underlying buffers.
+        /// </summary>
+        public static void Resize<T>(ref VBuffer<T> dst, int newLogicalLength, int? valuesCount = null)
+        {
+            dst = VBufferMutationContext.Create(ref dst, newLogicalLength, valuesCount)
+                .CreateBuffer();
+        }
     }
 }
diff --git a/src/Microsoft.ML.Data/Data/BufferBuilder.cs b/src/Microsoft.ML.Data/Data/BufferBuilder.cs
@@ -434,8 +434,7 @@ public void GetResult(ref VBuffer<T> buffer)
         {
             if (IsEmpty)
             {
-                buffer = VBufferMutationContext.Create(ref buffer, _length, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref buffer, _length, 0);
                 return;
             }
 
diff --git a/src/Microsoft.ML.Data/DataLoadSave/Text/TextLoaderParser.cs b/src/Microsoft.ML.Data/DataLoadSave/Text/TextLoaderParser.cs
@@ -403,8 +403,7 @@ public void Get(ref VBuffer<TItem> dst)
 
                     if (_count == 0)
                     {
-                        dst = VBufferMutationContext.Create(ref dst, _size, 0)
-                            .CreateBuffer();
+                        VBufferUtils.Resize(ref dst, _size, 0);
                         return;
                     }
 
diff --git a/src/Microsoft.ML.Data/DataView/Transposer.cs b/src/Microsoft.ML.Data/DataView/Transposer.cs
@@ -1308,8 +1308,7 @@ private ValueGetter<VBuffer<T>> CreateGetter(int col)
                                     int scount = slim - smin;
                                     if (scount == 0)
                                     {
-                                        value = VBufferMutationContext.Create(ref value, len, 0)
-                                            .CreateBuffer();
+                                        VBufferUtils.Resize(ref value, len, 0);
                                         return;
                                     }
 
diff --git a/src/Microsoft.ML.Data/Depricated/Vector/VBufferMathUtils.cs b/src/Microsoft.ML.Data/Depricated/Vector/VBufferMathUtils.cs
@@ -108,8 +108,7 @@ public static void ScaleBy(in VBuffer<Float> src, ref VBuffer<Float> dst, Float
             if (count == 0)
             {
                 // dst is a zero vector.
-                dst = VBufferMutationContext.Create(ref dst, length, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref dst, length, 0);
                 return;
             }
 
@@ -392,14 +391,13 @@ public static void ScaleInto(in VBuffer<Float> src, Float c, ref VBuffer<Float>
                 {
                     // Due to sparsity preservation from src, dst must be dense, in the same way.
                     var mutation = VBufferMutationContext.Create(ref dst, src.Length);
-                    if (!mutation.CreatedNewValues) // We need to clear it
+                    if (!mutation.CreatedNewValues) // We need to clear it.
                         mutation.Values.Clear();
                     dst = mutation.CreateBuffer();
                 }
                 else
                 {
-                    dst = VBufferMutationContext.Create(ref dst, src.Length, 0)
-                        .CreateBuffer();
+                    VBufferUtils.Resize(ref dst, src.Length, 0);
                 }
             }
             else if (c == -1)
diff --git a/src/Microsoft.ML.Data/Transforms/DropSlotsTransform.cs b/src/Microsoft.ML.Data/Transforms/DropSlotsTransform.cs
@@ -701,8 +701,7 @@ private ValueGetter<VBuffer<TDst>> MakeVecTrivialGetter<TDst>()
         // Delegates onto instance methods are more efficient than delegates onto static methods.
         private void VecTrivialGetter<TDst>(ref VBuffer<TDst> value)
         {
-            value = VBufferMutationContext.Create(ref value, 1, 0)
-                .CreateBuffer();
+            VBufferUtils.Resize(ref value, 1, 0);
         }
 
         private Delegate MakeVecGetter(IRow input, int iinfo)
diff --git a/src/Microsoft.ML.Data/Transforms/HashTransform.cs b/src/Microsoft.ML.Data/Transforms/HashTransform.cs
@@ -746,8 +746,7 @@ private static ValueGetter<VBuffer<uint>> MakeVectorHashGetter<T, THash>(uint se
                     var srcValues = src.GetValues();
                     if (srcValues.Length == 0)
                     {
-                        dst = VBufferMutationContext.Create(ref dst, src.Length, 0)
-                            .CreateBuffer();
+                        VBufferUtils.Resize(ref dst, src.Length, 0);
                         return;
                     }
                     var mutation = VBufferMutationContext.Create(ref dst, src.Length, srcValues.Length);
@@ -809,8 +808,7 @@ private static ValueGetter<VBuffer<uint>> MakeVectorOrderedHashGetter<T, THash>(
                     var srcValues = src.GetValues();
                     if (srcValues.Length == 0)
                     {
-                        dst = VBufferMutationContext.Create(ref dst, src.Length, 0)
-                            .CreateBuffer();
+                        VBufferUtils.Resize(ref dst, src.Length, 0);
                         return;
                     }
                     var mutation = VBufferMutationContext.Create(ref dst, src.Length, srcValues.Length);
diff --git a/src/Microsoft.ML.Data/Utilities/SlotDropper.cs b/src/Microsoft.ML.Data/Utilities/SlotDropper.cs
@@ -107,8 +107,7 @@ public void DropSlots<TDst>(ref VBuffer<TDst> src, ref VBuffer<TDst> dst)
             if (newLength == 0)
             {
                 // All slots dropped.
-                dst = VBufferMutationContext.Create(ref dst, 1, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref dst, 1, 0);
                 return;
             }
 
diff --git a/src/Microsoft.ML.Ensemble/OutputCombiners/MultiVoting.cs b/src/Microsoft.ML.Ensemble/OutputCombiners/MultiVoting.cs
@@ -77,8 +77,7 @@ private void CombineCore(ref VBuffer<Single> dst, VBuffer<Single>[] src, Single[
             int count = Utils.Size(src);
             if (count == 0)
             {
-                dst = VBufferMutationContext.Create(ref dst, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref dst, 0);
                 return;
             }
 
diff --git a/src/Microsoft.ML.FastTree/BinFile/BinFinder.cs b/src/Microsoft.ML.FastTree/BinFile/BinFinder.cs
@@ -54,9 +54,9 @@ public BinFinder()
         /// <paramref name="counts"/></returns>
         private int FindDistinctCounts(in VBuffer<Double> values, double[] valueBuffer, double[] distinctValues, int[] counts)
         {
-            var valueValues = values.GetValues();
-            var valuesCount = valueValues.Length;
-            if (valuesCount == 0)
+            var explicitValues = values.GetValues();
+            var explicitValuesCount = explicitValues.Length;
+            if (explicitValuesCount == 0)
             {
                 if (values.Length == 0)
                     return 0;
@@ -66,9 +66,9 @@ private int FindDistinctCounts(in VBuffer<Double> values, double[] valueBuffer,
             }
 
             // Get histogram of values
-            Contracts.Assert(valueBuffer.Length >= valuesCount);
-            valueValues.CopyTo(valueBuffer);
-            Array.Sort(valueBuffer, 0, valuesCount);
+            Contracts.Assert(valueBuffer.Length >= explicitValuesCount);
+            explicitValues.CopyTo(valueBuffer);
+            Array.Sort(valueBuffer, 0, explicitValuesCount);
             // Note that Array.Sort will, by MSDN documentation, make NaN be the first item of a sorted
             // list (that is, NaN is considered to be ordered "below" any other value for the purpose of
             // a sort, including negative infinity). So when checking if values contains no NaN values, it
@@ -80,13 +80,13 @@ private int FindDistinctCounts(in VBuffer<Double> values, double[] valueBuffer,
             {
                 // Implicit zeros at the head.
                 distinctValues[0] = 0;
-                counts[0] = values.Length - valuesCount;
+                counts[0] = values.Length - explicitValuesCount;
                 idist = 1;
             }
             double last = distinctValues[idist] = valueBuffer[0];
             counts[idist] = 1;
 
-            for (int i = 1; i < valuesCount; ++i)
+            for (int i = 1; i < explicitValuesCount; ++i)
             {
                 double curr = valueBuffer[i];
                 if (curr != last)
@@ -98,7 +98,7 @@ private int FindDistinctCounts(in VBuffer<Double> values, double[] valueBuffer,
                     {
                         // This boundary is going from negative, to non-negative, and there are "implicit" zeros.
                         distinctValues[idist] = 0;
-                        counts[idist] = values.Length - valuesCount;
+                        counts[idist] = values.Length - explicitValuesCount;
                         if (curr == 0)
                         {
                             // No need to do any more work.
@@ -123,7 +123,7 @@ private int FindDistinctCounts(in VBuffer<Double> values, double[] valueBuffer,
             {
                 // Implicit zeros at the tail.
                 distinctValues[++idist] = 0;
-                counts[idist] = values.Length - valuesCount;
+                counts[idist] = values.Length - explicitValuesCount;
             }
 
             return idist + 1;
diff --git a/src/Microsoft.ML.HalLearners/OlsLinearRegression.cs b/src/Microsoft.ML.HalLearners/OlsLinearRegression.cs
@@ -278,10 +278,11 @@ private OlsLinearRegressionPredictor TrainCore(IChannel ch, FloatLabelCursor.Fac
             for (int i = 0; i < beta.Length; ++i)
                 ch.Check(FloatUtils.IsFinite(beta[i]), "Non-finite values detected in OLS solution");
 
-            var weights = VBufferUtils.CreateDense<float>(beta.Length - 1);
-            var weightsMutation = VBufferMutationContext.CreateFromBuffer(ref weights);
+            var weightsValues = new float[beta.Length - 1];
             for (int i = 1; i < beta.Length; ++i)
-                weightsMutation.Values[i - 1] = (float)beta[i];
+                weightsValues[i - 1] = (float)beta[i];
+            var weights = new VBuffer<float>(weightsValues.Length, weightsValues);
+
             var bias = (float)beta[0];
             if (!(_l2Weight > 0) && m == n)
             {
diff --git a/src/Microsoft.ML.ImageAnalytics/ImagePixelExtractorTransform.cs b/src/Microsoft.ML.ImageAnalytics/ImagePixelExtractorTransform.cs
@@ -478,8 +478,7 @@ private ValueGetter<VBuffer<TValue>> GetGetterCore<TValue>(IRow input, int iinfo
 
                         if (src == null)
                         {
-                            dst = VBufferMutationContext.Create(ref dst, size, 0)
-                                .CreateBuffer();
+                            VBufferUtils.Resize(ref dst, size, 0);
                             return;
                         }
 
@@ -493,6 +492,7 @@ private ValueGetter<VBuffer<TValue>> GetGetterCore<TValue>(IRow input, int iinfo
                         float scale = ex.Scale;
                         Contracts.Assert(scale != 0);
 
+                        // REVIEW: split the getter into 2 specialized getters, one for float case and one for byte case.
                         Span<float> vf = typeof(TValue) == typeof(float) ? MemoryMarshal.Cast<TValue, float>(mutation.Values) : default;
                         Span<byte> vb = typeof(TValue) == typeof(byte) ? MemoryMarshal.Cast<TValue, byte>(mutation.Values) : default;
                         Contracts.Assert(!vf.IsEmpty || !vb.IsEmpty);
diff --git a/src/Microsoft.ML.StandardLearners/Standard/Online/LinearSvm.cs b/src/Microsoft.ML.StandardLearners/Standard/Online/LinearSvm.cs
@@ -119,8 +119,7 @@ private void BeginBatch()
                 _batch++;
                 _numBatchExamples = 0;
                 _biasUpdate = 0;
-                _weightsUpdate = VBufferMutationContext.Create(ref _weightsUpdate, _weightsUpdate.Length, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref _weightsUpdate, _weightsUpdate.Length, 0);
             }
 
             private void FinishBatch(in VBuffer<Float> weightsUpdate, Float weightsUpdateScale)
diff --git a/src/Microsoft.ML.TensorFlow/TensorFlow/TensorflowUtils.cs b/src/Microsoft.ML.TensorFlow/TensorFlow/TensorflowUtils.cs
@@ -115,10 +115,10 @@ public static ISchema GetModelSchema(IExceptionContext ectx, string modelFile)
                     Contracts.Assert(metadataType.IsKnownSizeVector && metadataType.ItemType.IsText);
                     schema.GetMetadata(TensorFlowUtils.InputOps, i, ref inputOps);
                 }
-                var inputOpsValues = inputOps.GetValues();
-                string[] inputOpsResult = new string[inputOpsValues.Length];
-                for (int j = 0; j < inputOpsValues.Length; j++)
-                    inputOpsResult[j] = inputOpsValues[j].ToString();
+
+                string[] inputOpsResult = inputOps.DenseValues()
+                    .Select(input => input.ToString())
+                    .ToArray();
 
                 yield return (name, opType.ToString(), type, inputOpsResult);
             }
diff --git a/src/Microsoft.ML.Transforms/GcnTransform.cs b/src/Microsoft.ML.Transforms/GcnTransform.cs
@@ -542,8 +542,7 @@ private static void FillValues(IExceptionContext ectx, in VBuffer<Float> src, re
 
             if (count == 0)
             {
-                dst = VBufferMutationContext.Create(ref dst, length, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref dst, length, 0);
                 return;
             }
             ectx.Assert(count > 0);
diff --git a/src/Microsoft.ML.Transforms/MissingValueDroppingTransformer.cs b/src/Microsoft.ML.Transforms/MissingValueDroppingTransformer.cs
@@ -240,8 +240,7 @@ private void DropNAsAndDefaults<TDst>(ref VBuffer<TDst> src, ref VBuffer<TDst> d
 
             if (newCount == 0)
             {
-                dst = VBufferMutationContext.Create(ref dst, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref dst, 0);
                 return;
             }
 
@@ -251,8 +250,7 @@ private void DropNAsAndDefaults<TDst>(ref VBuffer<TDst> src, ref VBuffer<TDst> d
                 if (!dst.IsDense)
                 {
                     Host.Assert(dst.GetValues().Length == newCount);
-                    dst = VBufferMutationContext.Create(ref dst, newCount)
-                        .CreateBuffer();
+                    VBufferUtils.Resize(ref dst, newCount);
                 }
                 return;
             }
@@ -286,8 +284,7 @@ private void DropNAs<TDst>(ref VBuffer<TDst> src, ref VBuffer<TDst> dst, InPredi
 
             if (newCount == 0)
             {
-                dst = VBufferMutationContext.Create(ref dst, src.Length - srcValues.Length, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref dst, src.Length - srcValues.Length, 0);
                 return;
             }
 
diff --git a/src/Microsoft.ML.Transforms/MissingValueIndicatorTransform.cs b/src/Microsoft.ML.Transforms/MissingValueIndicatorTransform.cs
@@ -276,8 +276,7 @@ private static void FillValues(Float input, ref VBuffer<Float> result)
         {
             if (input == 0)
             {
-                result = VBufferMutationContext.Create(ref result, 2, 0)
-                    .CreateBuffer();
+                VBufferUtils.Resize(ref result, 2, 0);
                 return;
             }
 
diff --git a/src/Microsoft.ML.Transforms/Text/LdaTransform.cs b/src/Microsoft.ML.Transforms/Text/LdaTransform.cs
diff --git a/src/Microsoft.ML.Transforms/Text/NgramTransform.cs b/src/Microsoft.ML.Transforms/Text/NgramTransform.cs
diff --git a/src/Microsoft.ML.Transforms/Text/WordTokenizeTransform.cs b/src/Microsoft.ML.Transforms/Text/WordTokenizeTransform.cs

Original file line number	Diff line number	Diff line change
`@@ -319,8 +319,7 @@ public static void GetSlotNames(RoleMappedSchema schema, RoleMappedSchema.Column`
`319`	`319`	`IReadOnlyList<ColumnInfo> list;`
`320`	`320`	`if ((list = schema?.GetColumns(role)) == null \|\| list.Count != 1 \|\| !schema.Schema.HasSlotNames(list[0].Index, vectorSize))`
`321`	`321`	`{`
`322`		`- slotNames = VBufferMutationContext.Create(ref slotNames, vectorSize, 0)`
`323`		`- .CreateBuffer();`
	`322`	`+ VBufferUtils.Resize(ref slotNames, vectorSize, 0);`
`324`	`323`	`}`
`325`	`324`	`else`
`326`	`325`	`schema.Schema.GetMetadata(Kinds.SlotNames, list[0].Index, ref slotNames);`
Original file line number	Diff line number	Diff line change
`@@ -1114,9 +1114,7 @@ public static int Count<TSource>(this ReadOnlySpan<TSource> source, Func<TSource`
`1114`	`1114`	`for (int i = 0; i < source.Length; i++)`
`1115`	`1115`	`{`
`1116`	`1116`	`if (predicate(source[i]))`
`1117`		`- {`
`1118`	`1117`	`result++;`
`1119`		`- }`
`1120`	`1118`	`}`
`1121`	`1119`	`return result;`
`1122`	`1120`	`}`
`@@ -1128,9 +1126,7 @@ public static bool All<TSource>(this ReadOnlySpan<TSource> source, Func<TSource,`
`1128`	`1126`	`for (int i = 0; i < source.Length; i++)`
`1129`	`1127`	`{`
`1130`	`1128`	`if (!predicate(source[i]))`
`1131`		`- {`
`1132`	`1129`	`return false;`
`1133`		`- }`
`1134`	`1130`	`}`
`1135`	`1131`	`return true;`
`1136`	`1132`	`}`
Original file line number	Diff line number	Diff line change
`@@ -314,10 +314,7 @@ public static void ForEachEitherDefined<T>(in VBuffer<T> a, in VBuffer<T> b, Act`
`314`	`314`	`/// </summary>`
`315`	`315`	`public static void Clear<T>(ref VBuffer<T> dst)`
`316`	`316`	`{`
`317`		`- int dstValuesCount = dst.GetValues().Length;`
`318`		`- if (dstValuesCount == 0)`
`319`		`- return;`
`320`		`- var mutation = VBufferMutationContext.Create(ref dst, dst.Length, dstValuesCount);`
	`317`	`+ var mutation = VBufferMutationContext.CreateFromBuffer(ref dst);`
`321`	`318`	`mutation.Values.Clear();`
`322`	`319`	`}`
`323`	`320`
`@@ -346,8 +343,7 @@ public static void Apply<T>(ref VBuffer<T> dst, SlotValueManipulator<T> manip)`
`346`	`343`	`{`
`347`	`344`	`Contracts.CheckValue(manip, nameof(manip));`
`348`	`345`
`349`		`- int dstValuesCount = dst.GetValues().Length;`
`350`		`- var mutation = VBufferMutationContext.Create(ref dst, dst.Length, dstValuesCount);`
	`346`	`+ var mutation = VBufferMutationContext.CreateFromBuffer(ref dst);`
`351`	`347`	`if (dst.IsDense)`
`352`	`348`	`{`
`353`	`349`	`for (int i = 0; i < mutation.Values.Length; i++)`
`@@ -381,8 +377,8 @@ public static void ApplyAt<T>(ref VBuffer<T> dst, int slot, SlotValueManipulator`
`381`	`377`	`Contracts.CheckValue(manip, nameof(manip));`
`382`	`378`	`Contracts.CheckValueOrNull(pred);`
`383`	`379`
`384`		`- int dstValuesCount = dst.GetValues().Length;`
`385`		`- var mutation = VBufferMutationContext.Create(ref dst, dst.Length, dstValuesCount);`
	`380`	`+ var mutation = VBufferMutationContext.CreateFromBuffer(ref dst);`
	`381`	`+ int dstValuesCount = mutation.Values.Length;`
`386`	`382`	`if (dst.IsDense)`
`387`	`383`	`{`
`388`	`384`	`// The vector is dense, so we can just do a direct access.`
`@@ -963,8 +959,7 @@ private static void ApplyWithCoreCopy<TSrc, TDst>(in VBuffer<TSrc> src, ref VBuf`
`963`	`959`	`{`
`964`	`960`	`if (srcValues.Length == 0)`
`965`	`961`	`{`
`966`		`- res = VBufferMutationContext.Create(ref res, length, 0)`
`967`		`- .CreateBuffer();`
	`962`	`+ Resize(ref res, length, 0);`
`968`	`963`	`}`
`969`	`964`	`else if (src.IsDense)`
`970`	`965`	`{`
`@@ -1209,8 +1204,7 @@ public static void ApplyIntoEitherDefined<TSrc, TDst>(in VBuffer<TSrc> src, ref`
`1209`	`1204`	`// equal lengths, but I don't care here.`
`1210`	`1205`	`if (srcValues.Length == 0)`
`1211`	`1206`	`{`
`1212`		`- dst = VBufferMutationContext.Create(ref dst, src.Length, 0)`
`1213`		`- .CreateBuffer();`
	`1207`	`+ Resize(ref dst, src.Length, 0);`
`1214`	`1208`	`return;`
`1215`	`1209`	`}`
`1216`	`1210`	`var mutation = VBufferMutationContext.Create(ref dst,`
`@@ -1263,8 +1257,7 @@ public static void ApplyInto<TSrc1, TSrc2, TDst>(in VBuffer<TSrc1> a, in VBuffer`
`1263`	`1257`	`if (aValues.Length == 0 && bValues.Length == 0)`
`1264`	`1258`	`{`
`1265`	`1259`	`// Case 1. Output will be empty.`
`1266`		`- dst = VBufferMutationContext.Create(ref dst, a.Length, 0)`
`1267`		`- .CreateBuffer();`
	`1260`	`+ Resize(ref dst, a.Length, 0);`
`1268`	`1261`	`return;`
`1269`	`1262`	`}`
`1270`	`1263`
`@@ -1441,5 +1434,15 @@ public static void Copy<T>(List<T> src, ref VBuffer<T> dst, int length)`
`1441`	`1434`	`}`
`1442`	`1435`	`dst = mutation.CreateBuffer();`
`1443`	`1436`	`}`
	`1437`	`+`
	`1438`	`+ /// <summary>`
	`1439`	`+ /// Updates the logical length and number of physical values to be represented in`
	`1440`	`+ /// <paramref name="dst"/>, while preserving the underlying buffers.`
	`1441`	`+ /// </summary>`
	`1442`	`+ public static void Resize<T>(ref VBuffer<T> dst, int newLogicalLength, int? valuesCount = null)`
	`1443`	`+ {`
	`1444`	`+ dst = VBufferMutationContext.Create(ref dst, newLogicalLength, valuesCount)`
	`1445`	`+ .CreateBuffer();`
	`1446`	`+ }`
`1444`	`1447`	`}`
`1445`	`1448`	`}`
Original file line number	Diff line number	Diff line change
`@@ -434,8 +434,7 @@ public void GetResult(ref VBuffer<T> buffer)`
`434`	`434`	`{`
`435`	`435`	`if (IsEmpty)`
`436`	`436`	`{`
`437`		`- buffer = VBufferMutationContext.Create(ref buffer, _length, 0)`
`438`		`- .CreateBuffer();`
	`437`	`+ VBufferUtils.Resize(ref buffer, _length, 0);`
`439`	`438`	`return;`
`440`	`439`	`}`
`441`	`440`
Original file line number	Diff line number	Diff line change
`@@ -403,8 +403,7 @@ public void Get(ref VBuffer<TItem> dst)`
`403`	`403`
`404`	`404`	`if (_count == 0)`
`405`	`405`	`{`
`406`		`- dst = VBufferMutationContext.Create(ref dst, _size, 0)`
`407`		`- .CreateBuffer();`
	`406`	`+ VBufferUtils.Resize(ref dst, _size, 0);`
`408`	`407`	`return;`
`409`	`408`	`}`
`410`	`409`
Original file line number	Diff line number	Diff line change
`@@ -1308,8 +1308,7 @@ private ValueGetter<VBuffer<T>> CreateGetter(int col)`
`1308`	`1308`	`int scount = slim - smin;`
`1309`	`1309`	`if (scount == 0)`
`1310`	`1310`	`{`
`1311`		`- value = VBufferMutationContext.Create(ref value, len, 0)`
`1312`		`- .CreateBuffer();`
	`1311`	`+ VBufferUtils.Resize(ref value, len, 0);`
`1313`	`1312`	`return;`
`1314`	`1313`	`}`
`1315`	`1314`
Original file line number	Diff line number	Diff line change
`@@ -108,8 +108,7 @@ public static void ScaleBy(in VBuffer<Float> src, ref VBuffer<Float> dst, Float`
`108`	`108`	`if (count == 0)`
`109`	`109`	`{`
`110`	`110`	`// dst is a zero vector.`
`111`		`- dst = VBufferMutationContext.Create(ref dst, length, 0)`
`112`		`- .CreateBuffer();`
	`111`	`+ VBufferUtils.Resize(ref dst, length, 0);`
`113`	`112`	`return;`
`114`	`113`	`}`
`115`	`114`
`@@ -392,14 +391,13 @@ public static void ScaleInto(in VBuffer<Float> src, Float c, ref VBuffer<Float>`
`392`	`391`	`{`
`393`	`392`	`// Due to sparsity preservation from src, dst must be dense, in the same way.`
`394`	`393`	`var mutation = VBufferMutationContext.Create(ref dst, src.Length);`
`395`		`- if (!mutation.CreatedNewValues) // We need to clear it`
	`394`	`+ if (!mutation.CreatedNewValues) // We need to clear it.`
`396`	`395`	`mutation.Values.Clear();`
`397`	`396`	`dst = mutation.CreateBuffer();`
`398`	`397`	`}`
`399`	`398`	`else`
`400`	`399`	`{`
`401`		`- dst = VBufferMutationContext.Create(ref dst, src.Length, 0)`
`402`		`- .CreateBuffer();`
	`400`	`+ VBufferUtils.Resize(ref dst, src.Length, 0);`
`403`	`401`	`}`
`404`	`402`	`}`
`405`	`403`	`else if (c == -1)`
Original file line number	Diff line number	Diff line change
`@@ -701,8 +701,7 @@ private ValueGetter<VBuffer<TDst>> MakeVecTrivialGetter<TDst>()`
`701`	`701`	`// Delegates onto instance methods are more efficient than delegates onto static methods.`
`702`	`702`	`private void VecTrivialGetter<TDst>(ref VBuffer<TDst> value)`
`703`	`703`	`{`
`704`		`- value = VBufferMutationContext.Create(ref value, 1, 0)`
`705`		`- .CreateBuffer();`
	`704`	`+ VBufferUtils.Resize(ref value, 1, 0);`
`706`	`705`	`}`
`707`	`706`
`708`	`707`	`private Delegate MakeVecGetter(IRow input, int iinfo)`
Original file line number	Diff line number	Diff line change
`@@ -746,8 +746,7 @@ private static ValueGetter<VBuffer<uint>> MakeVectorHashGetter<T, THash>(uint se`
`746`	`746`	`var srcValues = src.GetValues();`
`747`	`747`	`if (srcValues.Length == 0)`
`748`	`748`	`{`
`749`		`- dst = VBufferMutationContext.Create(ref dst, src.Length, 0)`
`750`		`- .CreateBuffer();`
	`749`	`+ VBufferUtils.Resize(ref dst, src.Length, 0);`
`751`	`750`	`return;`
`752`	`751`	`}`
`753`	`752`	`var mutation = VBufferMutationContext.Create(ref dst, src.Length, srcValues.Length);`
`@@ -809,8 +808,7 @@ private static ValueGetter<VBuffer<uint>> MakeVectorOrderedHashGetter<T, THash>(`
`809`	`808`	`var srcValues = src.GetValues();`
`810`	`809`	`if (srcValues.Length == 0)`
`811`	`810`	`{`
`812`		`- dst = VBufferMutationContext.Create(ref dst, src.Length, 0)`
`813`		`- .CreateBuffer();`
	`811`	`+ VBufferUtils.Resize(ref dst, src.Length, 0);`
`814`	`812`	`return;`
`815`	`813`	`}`
`816`	`814`	`var mutation = VBufferMutationContext.Create(ref dst, src.Length, srcValues.Length);`