Contracts.Assert statements valid for Debug-Intrinsics (dotnet#1676)

Anipik · web-flow · commit 8099f58b50cd · 2018-11-21T09:55:38.000-08:00
* Contracts.Assert statements valid for Debug-Intrinsics

* Fixing netcoreapp 3.0 build
diff --git a/Directory.Build.props b/Directory.Build.props
@@ -113,6 +113,7 @@
   <!-- Taken from https://github.com/dotnet/sdk/blob/073c98b92c81066c6c2e17c3674adbb6e833409a/src/Tasks/Microsoft.NET.Build.Tasks/targets/Microsoft.NET.Sdk.props#L41-L47 -->
   <PropertyGroup Condition="'$(Configuration)' == 'Debug-Intrinsics'">
     <DebugSymbols>true</DebugSymbols>
+    <DefineConstants>$(DefineContants);DEBUG</DefineConstants>
     <Optimize>false</Optimize>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)' == 'Release-Intrinsics'">
diff --git a/src/Microsoft.ML.CpuMath/AssemblyInfo.cs b/src/Microsoft.ML.CpuMath/AssemblyInfo.cs
@@ -6,6 +6,7 @@
 using Microsoft.ML;
 
 [assembly: InternalsVisibleTo("Microsoft.ML.CpuMath.UnitTests.netstandard" + PublicKey.TestValue)]
+[assembly: InternalsVisibleTo("Microsoft.ML.CpuMath.UnitTests.netcoreapp" + PublicKey.TestValue)]
 [assembly: InternalsVisibleTo("Microsoft.ML.Data" + PublicKey.Value)]
 [assembly: InternalsVisibleTo("Microsoft.ML.FastTree" + PublicKey.Value)]
 [assembly: InternalsVisibleTo("Microsoft.ML.HalLearners" + PublicKey.Value)]
diff --git a/src/Microsoft.ML.CpuMath/AvxIntrinsics.cs b/src/Microsoft.ML.CpuMath/AvxIntrinsics.cs
@@ -153,16 +153,13 @@ private static Vector256<float> MultiplyAdd(Vector256<float> src1, Vector256<flo
         // Multiply matrix times vector into vector.
         public static unsafe void MatMul(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Size == dst.Size);
-
             MatMul(mat.Items, src.Items, dst.Items, crow, ccol);
         }
 
         public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)
         {
             Contracts.Assert(crow % 4 == 0);
             Contracts.Assert(ccol % 4 == 0);
-            Contracts.Assert(src.Length == dst.Length);
 
             fixed (float* psrc = &MemoryMarshal.GetReference(src))
             fixed (float* pdst = &MemoryMarshal.GetReference(dst))
@@ -310,8 +307,6 @@ public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> sr
         public static unsafe void MatMulP(AlignedArray mat, ReadOnlySpan<int> rgposSrc, AlignedArray src,
                                 int posMin, int iposMin, int iposEnd, AlignedArray dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Size == dst.Size);
-
             MatMulP(mat.Items, rgposSrc, src.Items, posMin, iposMin, iposEnd, dst.Items, crow, ccol);
         }
 
@@ -320,7 +315,6 @@ public static unsafe void MatMulP(ReadOnlySpan<float> mat, ReadOnlySpan<int> rgp
         {
             Contracts.Assert(crow % 8 == 0);
             Contracts.Assert(ccol % 8 == 0);
-            Contracts.Assert(src.Length == dst.Length);
 
             // REVIEW: For extremely sparse inputs, interchanging the loops would
             // likely be more efficient.
@@ -474,16 +468,13 @@ Vector256<float> SparseMultiplicationAcrossRow()
 
         public static unsafe void MatMulTran(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Size == dst.Size);
-
             MatMulTran(mat.Items, src.Items, dst.Items, crow, ccol);
         }
 
         public static unsafe void MatMulTran(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)
         {
             Contracts.Assert(crow % 4 == 0);
             Contracts.Assert(ccol % 4 == 0);
-            Contracts.Assert(src.Length == dst.Length);
 
             fixed (float* psrc = &MemoryMarshal.GetReference(src))
             fixed (float* pdst = &MemoryMarshal.GetReference(dst))
diff --git a/src/Microsoft.ML.CpuMath/CpuMathUtils.netcoreapp.cs b/src/Microsoft.ML.CpuMath/CpuMathUtils.netcoreapp.cs
@@ -91,7 +91,6 @@ public static void MatrixTimesSource(bool transpose, AlignedArray matrix, Aligne
         public static void MatrixTimesSource(AlignedArray matrix, ReadOnlySpan<int> rgposSrc, AlignedArray sourceValues,
             int posMin, int iposMin, int iposLimit, AlignedArray destination, int stride)
         {
-            Contracts.AssertValue(rgposSrc);
             Contracts.Assert(iposMin >= 0);
             Contracts.Assert(iposMin <= iposLimit);
             Contracts.Assert(iposLimit <= rgposSrc.Length);
diff --git a/src/Microsoft.ML.CpuMath/Microsoft.ML.CpuMath.csproj b/src/Microsoft.ML.CpuMath/Microsoft.ML.CpuMath.csproj
@@ -22,6 +22,9 @@
     <Compile Remove="AvxIntrinsics.cs" />
 
     <PackageReference Include="System.Memory" Version="$(SystemMemoryVersion)" />
+  </ItemGroup>
+
+  <ItemGroup>
     <ProjectReference Include="..\..\src\Microsoft.ML.Core\Microsoft.ML.Core.csproj" />
   </ItemGroup>
 
diff --git a/src/Microsoft.ML.CpuMath/SseIntrinsics.cs b/src/Microsoft.ML.CpuMath/SseIntrinsics.cs
@@ -117,16 +117,13 @@ internal static Vector128<float> GetNewDst128(in Vector128<float> xDst1, in Vect
         // Multiply matrix times vector into vector.
         public static unsafe void MatMul(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Size == dst.Size);
-
             MatMul(mat.Items, src.Items, dst.Items, crow, ccol);
         }
 
         public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)
         {
             Contracts.Assert(crow % 4 == 0);
             Contracts.Assert(ccol % 4 == 0);
-            Contracts.Assert(src.Length == dst.Length);
 
             fixed (float* psrc = &MemoryMarshal.GetReference(src))
             fixed (float* pdst = &MemoryMarshal.GetReference(dst))
@@ -282,15 +279,12 @@ public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> sr
         public static unsafe void MatMulP(AlignedArray mat, ReadOnlySpan<int> rgposSrc, AlignedArray src,
                                 int posMin, int iposMin, int iposEnd, AlignedArray dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Size == dst.Size);
-
             MatMulP(mat.Items, rgposSrc, src.Items, posMin, iposMin, iposEnd, dst.Items, crow, ccol);
         }
 
         public static unsafe void MatMulP(ReadOnlySpan<float> mat, ReadOnlySpan<int> rgposSrc, ReadOnlySpan<float> src,
                                         int posMin, int iposMin, int iposEnd, Span<float> dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Length == dst.Length);
             Contracts.Assert(crow % 4 == 0);
             Contracts.Assert(ccol % 4 == 0);
 
@@ -449,14 +443,11 @@ Vector128<float> SparseMultiplicationAcrossRow()
 
         public static unsafe void MatMulTran(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Size == dst.Size);
-
             MatMulTran(mat.Items, src.Items, dst.Items, crow, ccol);
         }
 
         public static unsafe void MatMulTran(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)
         {
-            Contracts.Assert(src.Length == dst.Length);
             Contracts.Assert(crow % 4 == 0);
             Contracts.Assert(ccol % 4 == 0);
 

Original file line number	Diff line number	Diff line change
`@@ -153,16 +153,13 @@ private static Vector256<float> MultiplyAdd(Vector256<float> src1, Vector256<flo`
`153`	`153`	`// Multiply matrix times vector into vector.`
`154`	`154`	`public static unsafe void MatMul(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)`
`155`	`155`	`{`
`156`		`- Contracts.Assert(src.Size == dst.Size);`
`157`		`-`
`158`	`156`	`MatMul(mat.Items, src.Items, dst.Items, crow, ccol);`
`159`	`157`	`}`
`160`	`158`
`161`	`159`	`public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)`
`162`	`160`	`{`
`163`	`161`	`Contracts.Assert(crow % 4 == 0);`
`164`	`162`	`Contracts.Assert(ccol % 4 == 0);`
`165`		`- Contracts.Assert(src.Length == dst.Length);`
`166`	`163`
`167`	`164`	`fixed (float* psrc = &MemoryMarshal.GetReference(src))`
`168`	`165`	`fixed (float* pdst = &MemoryMarshal.GetReference(dst))`
`@@ -310,8 +307,6 @@ public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> sr`
`310`	`307`	`public static unsafe void MatMulP(AlignedArray mat, ReadOnlySpan<int> rgposSrc, AlignedArray src,`
`311`	`308`	`int posMin, int iposMin, int iposEnd, AlignedArray dst, int crow, int ccol)`
`312`	`309`	`{`
`313`		`- Contracts.Assert(src.Size == dst.Size);`
`314`		`-`
`315`	`310`	`MatMulP(mat.Items, rgposSrc, src.Items, posMin, iposMin, iposEnd, dst.Items, crow, ccol);`
`316`	`311`	`}`
`317`	`312`
`@@ -320,7 +315,6 @@ public static unsafe void MatMulP(ReadOnlySpan<float> mat, ReadOnlySpan<int> rgp`
`320`	`315`	`{`
`321`	`316`	`Contracts.Assert(crow % 8 == 0);`
`322`	`317`	`Contracts.Assert(ccol % 8 == 0);`
`323`		`- Contracts.Assert(src.Length == dst.Length);`
`324`	`318`
`325`	`319`	`// REVIEW: For extremely sparse inputs, interchanging the loops would`
`326`	`320`	`// likely be more efficient.`
`@@ -474,16 +468,13 @@ Vector256<float> SparseMultiplicationAcrossRow()`
`474`	`468`
`475`	`469`	`public static unsafe void MatMulTran(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)`
`476`	`470`	`{`
`477`		`- Contracts.Assert(src.Size == dst.Size);`
`478`		`-`
`479`	`471`	`MatMulTran(mat.Items, src.Items, dst.Items, crow, ccol);`
`480`	`472`	`}`
`481`	`473`
`482`	`474`	`public static unsafe void MatMulTran(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)`
`483`	`475`	`{`
`484`	`476`	`Contracts.Assert(crow % 4 == 0);`
`485`	`477`	`Contracts.Assert(ccol % 4 == 0);`
`486`		`- Contracts.Assert(src.Length == dst.Length);`
`487`	`478`
`488`	`479`	`fixed (float* psrc = &MemoryMarshal.GetReference(src))`
`489`	`480`	`fixed (float* pdst = &MemoryMarshal.GetReference(dst))`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,6 @@ public static void MatrixTimesSource(bool transpose, AlignedArray matrix, Aligne`
`91`	`91`	`public static void MatrixTimesSource(AlignedArray matrix, ReadOnlySpan<int> rgposSrc, AlignedArray sourceValues,`
`92`	`92`	`int posMin, int iposMin, int iposLimit, AlignedArray destination, int stride)`
`93`	`93`	`{`
`94`		`- Contracts.AssertValue(rgposSrc);`
`95`	`94`	`Contracts.Assert(iposMin >= 0);`
`96`	`95`	`Contracts.Assert(iposMin <= iposLimit);`
`97`	`96`	`Contracts.Assert(iposLimit <= rgposSrc.Length);`
Original file line number	Diff line number	Diff line change
`@@ -117,16 +117,13 @@ internal static Vector128<float> GetNewDst128(in Vector128<float> xDst1, in Vect`
`117`	`117`	`// Multiply matrix times vector into vector.`
`118`	`118`	`public static unsafe void MatMul(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)`
`119`	`119`	`{`
`120`		`- Contracts.Assert(src.Size == dst.Size);`
`121`		`-`
`122`	`120`	`MatMul(mat.Items, src.Items, dst.Items, crow, ccol);`
`123`	`121`	`}`
`124`	`122`
`125`	`123`	`public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)`
`126`	`124`	`{`
`127`	`125`	`Contracts.Assert(crow % 4 == 0);`
`128`	`126`	`Contracts.Assert(ccol % 4 == 0);`
`129`		`- Contracts.Assert(src.Length == dst.Length);`
`130`	`127`
`131`	`128`	`fixed (float* psrc = &MemoryMarshal.GetReference(src))`
`132`	`129`	`fixed (float* pdst = &MemoryMarshal.GetReference(dst))`
`@@ -282,15 +279,12 @@ public static unsafe void MatMul(ReadOnlySpan<float> mat, ReadOnlySpan<float> sr`
`282`	`279`	`public static unsafe void MatMulP(AlignedArray mat, ReadOnlySpan<int> rgposSrc, AlignedArray src,`
`283`	`280`	`int posMin, int iposMin, int iposEnd, AlignedArray dst, int crow, int ccol)`
`284`	`281`	`{`
`285`		`- Contracts.Assert(src.Size == dst.Size);`
`286`		`-`
`287`	`282`	`MatMulP(mat.Items, rgposSrc, src.Items, posMin, iposMin, iposEnd, dst.Items, crow, ccol);`
`288`	`283`	`}`
`289`	`284`
`290`	`285`	`public static unsafe void MatMulP(ReadOnlySpan<float> mat, ReadOnlySpan<int> rgposSrc, ReadOnlySpan<float> src,`
`291`	`286`	`int posMin, int iposMin, int iposEnd, Span<float> dst, int crow, int ccol)`
`292`	`287`	`{`
`293`		`- Contracts.Assert(src.Length == dst.Length);`
`294`	`288`	`Contracts.Assert(crow % 4 == 0);`
`295`	`289`	`Contracts.Assert(ccol % 4 == 0);`
`296`	`290`
`@@ -449,14 +443,11 @@ Vector128<float> SparseMultiplicationAcrossRow()`
`449`	`443`
`450`	`444`	`public static unsafe void MatMulTran(AlignedArray mat, AlignedArray src, AlignedArray dst, int crow, int ccol)`
`451`	`445`	`{`
`452`		`- Contracts.Assert(src.Size == dst.Size);`
`453`		`-`
`454`	`446`	`MatMulTran(mat.Items, src.Items, dst.Items, crow, ccol);`
`455`	`447`	`}`
`456`	`448`
`457`	`449`	`public static unsafe void MatMulTran(ReadOnlySpan<float> mat, ReadOnlySpan<float> src, Span<float> dst, int crow, int ccol)`
`458`	`450`	`{`
`459`		`- Contracts.Assert(src.Length == dst.Length);`
`460`	`451`	`Contracts.Assert(crow % 4 == 0);`
`461`	`452`	`Contracts.Assert(ccol % 4 == 0);`
`462`	`453`