Fix downlevel build break in TensorPrimitives (#92269)

stephentoub · ericstj · web-flow · commit 32c3355c502c · 2023-09-20T06:42:27.000-07:00
* Fix downlevel build break in TensorPrimitives

* Make net6.0 Tensors use ns2.0 implementation

* Add net6.0 and net7.0 to Tensors temporarily since those are shipping in 8.0 branch

* Only build net6.0 and net7.0 Tensors when not in source-build

---------

Co-authored-by: Eric StJohn &lt;ericstj@microsoft.com&gt;
diff --git a/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/ref/System.Numerics.Tensors.csproj
@@ -2,13 +2,14 @@
 
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
+    <TargetFrameworks Condition="'$(DotNetBuildFromSource)' != 'true'">$(TargetFrameworks);net7.0;net6.0</TargetFrameworks>
   </PropertyGroup>
 
   <ItemGroup>
     <Compile Include="System.Numerics.Tensors.cs" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
     <Compile Include="System.Numerics.Tensors.netcore.cs" />
   </ItemGroup>
 
diff --git a/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj b/src/libraries/System.Numerics.Tensors/src/System.Numerics.Tensors.csproj
@@ -2,6 +2,7 @@
   
   <PropertyGroup>
     <TargetFrameworks>$(NetCoreAppCurrent);$(NetCoreAppPrevious);$(NetCoreAppMinimum);netstandard2.0;$(NetFrameworkMinimum)</TargetFrameworks>
+    <TargetFrameworks Condition="'$(DotNetBuildFromSource)' != 'true'">$(TargetFrameworks);net7.0;net6.0</TargetFrameworks>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IsPackable>true</IsPackable>
     <PackageDescription>Provides support for operating over tensors.</PackageDescription>
@@ -16,11 +17,11 @@
     <Compile Include="System\ThrowHelper.cs" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' != '.NETCoreApp'">
+  <ItemGroup Condition="!$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
     <Compile Include="System\Numerics\Tensors\TensorPrimitives.netstandard.cs" />
   </ItemGroup>
 
-  <ItemGroup Condition="'$(TargetFrameworkIdentifier)' == '.NETCoreApp'">
+  <ItemGroup Condition="$([MSBuild]::IsTargetFrameworkCompatible('$(TargetFramework)', 'net7.0'))">
     <Compile Include="System\Numerics\Tensors\TensorPrimitives.netcore.cs" />
   </ItemGroup>
 
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netcore.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netcore.cs
@@ -1159,23 +1159,29 @@ public static float Invoke(Vector512<float> x)
             public static float Invoke(float x) => -x;
             public static Vector128<float> Invoke(Vector128<float> x) => -x;
             public static Vector256<float> Invoke(Vector256<float> x) => -x;
+#if NET8_0_OR_GREATER
             public static Vector512<float> Invoke(Vector512<float> x) => -x;
+#endif
         }
 
         private readonly struct AddMultiplyOperator : ITernaryOperator
         {
             public static float Invoke(float x, float y, float z) => (x + y) * z;
             public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y, Vector128<float> z) => (x + y) * z;
             public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y, Vector256<float> z) => (x + y) * z;
+#if NET8_0_OR_GREATER
             public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y, Vector512<float> z) => (x + y) * z;
+#endif
         }
 
         private readonly struct MultiplyAddOperator : ITernaryOperator
         {
             public static float Invoke(float x, float y, float z) => (x * y) + z;
             public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y, Vector128<float> z) => (x * y) + z;
             public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y, Vector256<float> z) => (x * y) + z;
+#if NET8_0_OR_GREATER
             public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y, Vector512<float> z) => (x * y) + z;
+#endif
         }
 
         private readonly struct LoadIdentity : IUnaryOperator
diff --git a/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netstandard.cs b/src/libraries/System.Numerics.Tensors/src/System/Numerics/Tensors/TensorPrimitives.netstandard.cs
@@ -69,8 +69,8 @@ private static float CosineSimilarityCore(ReadOnlySpan<float> x, ReadOnlySpan<fl
 
         private static float Aggregate<TLoad, TAggregate>(
             float identityValue, ReadOnlySpan<float> x, TLoad load = default, TAggregate aggregate = default)
-            where TLoad : IUnaryOperator
-            where TAggregate : IBinaryOperator
+            where TLoad : struct, IUnaryOperator
+            where TAggregate : struct, IBinaryOperator
         {
             // Initialize the result to the identity value
             float result = identityValue;
@@ -112,8 +112,8 @@ private static float Aggregate<TLoad, TAggregate>(
 
         private static float Aggregate<TBinary, TAggregate>(
             float identityValue, ReadOnlySpan<float> x, ReadOnlySpan<float> y, TBinary binary = default, TAggregate aggregate = default)
-            where TBinary : IBinaryOperator
-            where TAggregate : IBinaryOperator
+            where TBinary : struct, IBinaryOperator
+            where TAggregate : struct, IBinaryOperator
         {
             // Initialize the result to the identity value
             float result = identityValue;
@@ -156,7 +156,7 @@ private static float Aggregate<TBinary, TAggregate>(
 
         private static void InvokeSpanIntoSpan<TUnaryOperator>(
             ReadOnlySpan<float> x, Span<float> destination, TUnaryOperator op = default)
-            where TUnaryOperator : IUnaryOperator
+            where TUnaryOperator : struct, IUnaryOperator
         {
             if (x.Length > destination.Length)
             {
@@ -203,7 +203,7 @@ private static void InvokeSpanIntoSpan<TUnaryOperator>(
 
         private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(
             ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination, TBinaryOperator op = default)
-            where TBinaryOperator : IBinaryOperator
+            where TBinaryOperator : struct, IBinaryOperator
         {
             if (x.Length != y.Length)
             {
@@ -258,7 +258,7 @@ private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(
 
         private static void InvokeSpanScalarIntoSpan<TBinaryOperator>(
             ReadOnlySpan<float> x, float y, Span<float> destination, TBinaryOperator op = default)
-            where TBinaryOperator : IBinaryOperator
+            where TBinaryOperator : struct, IBinaryOperator
         {
             if (x.Length > destination.Length)
             {
@@ -309,7 +309,7 @@ private static void InvokeSpanScalarIntoSpan<TBinaryOperator>(
 
         private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(
             ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> z, Span<float> destination, TTernaryOperator op = default)
-            where TTernaryOperator : ITernaryOperator
+            where TTernaryOperator : struct, ITernaryOperator
         {
             if (x.Length != y.Length || x.Length != z.Length)
             {
@@ -369,7 +369,7 @@ private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(
 
         private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(
             ReadOnlySpan<float> x, ReadOnlySpan<float> y, float z, Span<float> destination, TTernaryOperator op = default)
-            where TTernaryOperator : ITernaryOperator
+            where TTernaryOperator : struct, ITernaryOperator
         {
             if (x.Length != y.Length)
             {
@@ -430,7 +430,7 @@ private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(
 
         private static void InvokeSpanScalarSpanIntoSpan<TTernaryOperator>(
             ReadOnlySpan<float> x, float y, ReadOnlySpan<float> z, Span<float> destination, TTernaryOperator op = default)
-            where TTernaryOperator : ITernaryOperator
+            where TTernaryOperator : struct, ITernaryOperator
         {
             if (x.Length != z.Length)
             {

Original file line number	Diff line number	Diff line change
`@@ -1159,23 +1159,29 @@ public static float Invoke(Vector512<float> x)`
`1159`	`1159`	`public static float Invoke(float x) => -x;`
`1160`	`1160`	`public static Vector128<float> Invoke(Vector128<float> x) => -x;`
`1161`	`1161`	`public static Vector256<float> Invoke(Vector256<float> x) => -x;`
	`1162`	`+#if NET8_0_OR_GREATER`
`1162`	`1163`	`public static Vector512<float> Invoke(Vector512<float> x) => -x;`
	`1164`	`+#endif`
`1163`	`1165`	`}`
`1164`	`1166`
`1165`	`1167`	`private readonly struct AddMultiplyOperator : ITernaryOperator`
`1166`	`1168`	`{`
`1167`	`1169`	`public static float Invoke(float x, float y, float z) => (x + y) * z;`
`1168`	`1170`	`public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y, Vector128<float> z) => (x + y) * z;`
`1169`	`1171`	`public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y, Vector256<float> z) => (x + y) * z;`
	`1172`	`+#if NET8_0_OR_GREATER`
`1170`	`1173`	`public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y, Vector512<float> z) => (x + y) * z;`
	`1174`	`+#endif`
`1171`	`1175`	`}`
`1172`	`1176`
`1173`	`1177`	`private readonly struct MultiplyAddOperator : ITernaryOperator`
`1174`	`1178`	`{`
`1175`	`1179`	`public static float Invoke(float x, float y, float z) => (x * y) + z;`
`1176`	`1180`	`public static Vector128<float> Invoke(Vector128<float> x, Vector128<float> y, Vector128<float> z) => (x * y) + z;`
`1177`	`1181`	`public static Vector256<float> Invoke(Vector256<float> x, Vector256<float> y, Vector256<float> z) => (x * y) + z;`
	`1182`	`+#if NET8_0_OR_GREATER`
`1178`	`1183`	`public static Vector512<float> Invoke(Vector512<float> x, Vector512<float> y, Vector512<float> z) => (x * y) + z;`
	`1184`	`+#endif`
`1179`	`1185`	`}`
`1180`	`1186`
`1181`	`1187`	`private readonly struct LoadIdentity : IUnaryOperator`
Original file line number	Diff line number	Diff line change
`@@ -69,8 +69,8 @@ private static float CosineSimilarityCore(ReadOnlySpan<float> x, ReadOnlySpan<fl`
`69`	`69`
`70`	`70`	`private static float Aggregate<TLoad, TAggregate>(`
`71`	`71`	`float identityValue, ReadOnlySpan<float> x, TLoad load = default, TAggregate aggregate = default)`
`72`		`- where TLoad : IUnaryOperator`
`73`		`- where TAggregate : IBinaryOperator`
	`72`	`+ where TLoad : struct, IUnaryOperator`
	`73`	`+ where TAggregate : struct, IBinaryOperator`
`74`	`74`	`{`
`75`	`75`	`// Initialize the result to the identity value`
`76`	`76`	`float result = identityValue;`
`@@ -112,8 +112,8 @@ private static float Aggregate<TLoad, TAggregate>(`
`112`	`112`
`113`	`113`	`private static float Aggregate<TBinary, TAggregate>(`
`114`	`114`	`float identityValue, ReadOnlySpan<float> x, ReadOnlySpan<float> y, TBinary binary = default, TAggregate aggregate = default)`
`115`		`- where TBinary : IBinaryOperator`
`116`		`- where TAggregate : IBinaryOperator`
	`115`	`+ where TBinary : struct, IBinaryOperator`
	`116`	`+ where TAggregate : struct, IBinaryOperator`
`117`	`117`	`{`
`118`	`118`	`// Initialize the result to the identity value`
`119`	`119`	`float result = identityValue;`
`@@ -156,7 +156,7 @@ private static float Aggregate<TBinary, TAggregate>(`
`156`	`156`
`157`	`157`	`private static void InvokeSpanIntoSpan<TUnaryOperator>(`
`158`	`158`	`ReadOnlySpan<float> x, Span<float> destination, TUnaryOperator op = default)`
`159`		`- where TUnaryOperator : IUnaryOperator`
	`159`	`+ where TUnaryOperator : struct, IUnaryOperator`
`160`	`160`	`{`
`161`	`161`	`if (x.Length > destination.Length)`
`162`	`162`	`{`
`@@ -203,7 +203,7 @@ private static void InvokeSpanIntoSpan<TUnaryOperator>(`
`203`	`203`
`204`	`204`	`private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(`
`205`	`205`	`ReadOnlySpan<float> x, ReadOnlySpan<float> y, Span<float> destination, TBinaryOperator op = default)`
`206`		`- where TBinaryOperator : IBinaryOperator`
	`206`	`+ where TBinaryOperator : struct, IBinaryOperator`
`207`	`207`	`{`
`208`	`208`	`if (x.Length != y.Length)`
`209`	`209`	`{`
`@@ -258,7 +258,7 @@ private static void InvokeSpanSpanIntoSpan<TBinaryOperator>(`
`258`	`258`
`259`	`259`	`private static void InvokeSpanScalarIntoSpan<TBinaryOperator>(`
`260`	`260`	`ReadOnlySpan<float> x, float y, Span<float> destination, TBinaryOperator op = default)`
`261`		`- where TBinaryOperator : IBinaryOperator`
	`261`	`+ where TBinaryOperator : struct, IBinaryOperator`
`262`	`262`	`{`
`263`	`263`	`if (x.Length > destination.Length)`
`264`	`264`	`{`
`@@ -309,7 +309,7 @@ private static void InvokeSpanScalarIntoSpan<TBinaryOperator>(`
`309`	`309`
`310`	`310`	`private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(`
`311`	`311`	`ReadOnlySpan<float> x, ReadOnlySpan<float> y, ReadOnlySpan<float> z, Span<float> destination, TTernaryOperator op = default)`
`312`		`- where TTernaryOperator : ITernaryOperator`
	`312`	`+ where TTernaryOperator : struct, ITernaryOperator`
`313`	`313`	`{`
`314`	`314`	`if (x.Length != y.Length \|\| x.Length != z.Length)`
`315`	`315`	`{`
`@@ -369,7 +369,7 @@ private static void InvokeSpanSpanSpanIntoSpan<TTernaryOperator>(`
`369`	`369`
`370`	`370`	`private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(`
`371`	`371`	`ReadOnlySpan<float> x, ReadOnlySpan<float> y, float z, Span<float> destination, TTernaryOperator op = default)`
`372`		`- where TTernaryOperator : ITernaryOperator`
	`372`	`+ where TTernaryOperator : struct, ITernaryOperator`
`373`	`373`	`{`
`374`	`374`	`if (x.Length != y.Length)`
`375`	`375`	`{`
`@@ -430,7 +430,7 @@ private static void InvokeSpanSpanScalarIntoSpan<TTernaryOperator>(`
`430`	`430`
`431`	`431`	`private static void InvokeSpanScalarSpanIntoSpan<TTernaryOperator>(`
`432`	`432`	`ReadOnlySpan<float> x, float y, ReadOnlySpan<float> z, Span<float> destination, TTernaryOperator op = default)`
`433`		`- where TTernaryOperator : ITernaryOperator`
	`433`	`+ where TTernaryOperator : struct, ITernaryOperator`
`434`	`434`	`{`
`435`	`435`	`if (x.Length != z.Length)`
`436`	`436`	`{`