Changes some of the CPU Math implemenation from our current version to use the new TensorPrimitives package.

.vsts-dotnet-ci.yml

@@ -149,12 +149,12 @@ jobs:
         _configuration: Debug
         _config_short: DFX
         _includeBenchmarkData: false
-        _targetFramework: net461
+        _targetFramework: net462
       Release_Build:
         _configuration: Release
         _config_short: RFX
         _includeBenchmarkData: false
-        _targetFramework: net461
+        _targetFramework: net462
     innerLoop: true
     vsTestConfiguration: "/Framework:.NETCoreApp,Version=v4.0"
     pool:

NuGet.config

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <configuration>
   <solution>
     <add key="disableSourceControlIntegration" value="true" />
@@ -13,6 +13,7 @@
     <add key="dotnet5-roslyn" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet5/nuget/v3/index.json" />
     <add key="mlnet-daily" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/MachineLearning/nuget/v3/index.json" />
     <add key="mlnet-assets" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/machinelearning-assets/nuget/v3/index.json" />
+    <add key="dotnet8" value="https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet8/nuget/v3/index.json" />
   </packageSources>
   <disabledPackageSources>
     <clear />

build/.night-build.yml

@@ -99,12 +99,12 @@ jobs:
         _configuration: Debug
         _config_short: DFX
         _includeBenchmarkData: false
-        _targetFramework: net461
+        _targetFramework: net462
       Release_Build:
         _configuration: Release
         _config_short: RFX
         _includeBenchmarkData: false
-        _targetFramework: net461
+        _targetFramework: net462
     nightlyBuild: true
     pool:
       vmImage: windows-2019

build/.outer-loop-build.yml

@@ -93,12 +93,12 @@ jobs:
         _configuration: Debug
         _config_short: DFX
         _includeBenchmarkData: false
-        _targetFramework: net461
+        _targetFramework: net462
       Release_Build:
         _configuration: Release
         _config_short: RFX
         _includeBenchmarkData: false
-        _targetFramework: net461
+        _targetFramework: net462
     pool:
       vmImage: windows-2019
 

build/ci/job-template.yml

@@ -201,6 +201,14 @@ jobs:
         contents: |
           artifacts/TestResults/**
         targetFolder: $(Build.ArtifactStagingDirectory)
+    - task: CopyFiles@2
+      displayName: Stage baseline files
+      condition: not(succeeded())
+      inputs:
+        sourceFolder: $(Build.SourcesDirectory)
+        contents: |
+          artifacts/bin/**/TestOutput/**
+        targetFolder: $(Build.ArtifactStagingDirectory)
     - task: CopyFiles@2
       displayName: Stage process dump and pdb if any
       condition: not(succeeded())

eng/Versions.props

@@ -24,6 +24,7 @@
     <SystemConfigurationConfigurationManagerVersion>6.0.1</SystemConfigurationConfigurationManagerVersion>
     <SystemIOFileSystemAccessControl>4.5.0</SystemIOFileSystemAccessControl>
     <SystemMemoryVersion>4.5.5</SystemMemoryVersion>
+    <SystemNumericsTensorsVersion>8.0.0-rtm.23523.3</SystemNumericsTensorsVersion>
     <SystemReflectionEmitLightweightVersion>4.3.0</SystemReflectionEmitLightweightVersion>
     <SystemReflectionEmitVersion>4.3.0</SystemReflectionEmitVersion>
     <SystemRuntimeCompilerServicesUnsafeVersion>6.0.0</SystemRuntimeCompilerServicesUnsafeVersion>

eng/helix.proj

@@ -147,9 +147,9 @@
     <ItemGroup>
       <HelixWorkItem Include="%(ProjectsWithTargetFramework.Filename)">
         <PayloadDirectory>$(BUILD_SOURCESDIRECTORY)\artifacts\bin\%(ProjectsWithTargetFramework.Filename)\$(BuildConfig)\%(ProjectsWithTargetFramework.TargetFrameworks)\</PayloadDirectory>
-        <PayloadDirectory Condition="%(ProjectsWithTargetFramework.TargetFrameworks) == 'net461'">$(BUILD_SOURCESDIRECTORY)\artifacts\bin\%(ProjectsWithTargetFramework.Filename)\$(BuildConfig)\%(ProjectsWithTargetFramework.TargetFrameworks)\win-x64</PayloadDirectory>
+        <PayloadDirectory Condition="%(ProjectsWithTargetFramework.TargetFrameworks) == 'net462'">$(BUILD_SOURCESDIRECTORY)\artifacts\bin\%(ProjectsWithTargetFramework.Filename)\$(BuildConfig)\%(ProjectsWithTargetFramework.TargetFrameworks)\win-x64</PayloadDirectory>
         <Command>dotnet exec --roll-forward Major --runtimeconfig %(ProjectsWithTargetFramework.Filename).runtimeconfig.json --depsfile %(ProjectsWithTargetFramework.Filename).deps.json $(HelixCorrelationPayloadPath)/xunit-runner/tools/netcoreapp2.0/xunit.console.dll %(ProjectsWithTargetFramework.Filename).dll -notrait Category=SkipInCI -xml testResults.xml</Command>
-        <Command Condition="$(TestTargetFramework.EndsWith('net461')) And %(ProjectsWithTargetFramework.TargetFrameworks) != 'net6.0'">$(HelixCorrelationPayloadPath)/xunit-runner/tools/net461/xunit.console.exe %(ProjectsWithTargetFramework.Filename).dll -notrait Category=SkipInCI -xml testResults.xml</Command>
+        <Command Condition="$(TestTargetFramework.EndsWith('net462')) And %(ProjectsWithTargetFramework.TargetFrameworks) != 'net6.0'">$(HelixCorrelationPayloadPath)/xunit-runner/tools/net462/xunit.console.exe %(ProjectsWithTargetFramework.Filename).dll -notrait Category=SkipInCI -xml testResults.xml</Command>
         <Timeout>01:00:00</Timeout>
         <Timeout Condition="$(HelixTargetQueues.ToLowerInvariant().Contains('osx'))">00:30:00</Timeout>
         <Timeout Condition="'$(WorkItemTimeout)' != ''">$(WorkItemTimeout)</Timeout>

src/Microsoft.ML.CpuMath/AvxIntrinsics.cs

@@ -15,7 +15,9 @@
 using System.Runtime.Intrinsics;
 using System.Runtime.Intrinsics.X86;
 using Microsoft.ML.Internal.CpuMath.Core;
+#pragma warning disable CS8981 // The type name only contains lower-cased ascii characters. Such names may become reserved for the language.
 using nuint = System.UInt64;
+#pragma warning restore CS8981 // The type name only contains lower-cased ascii characters. Such names may become reserved for the language.
 
 namespace Microsoft.ML.Internal.CpuMath
 {

src/Microsoft.ML.CpuMath/CpuMathUtils.cs

@@ -0,0 +1,197 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Runtime.CompilerServices;
+using System.Numerics.Tensors;
+using Microsoft.ML.Internal.CpuMath.Core;
+
+namespace Microsoft.ML.Internal.CpuMath
+{
+    [BestFriend]
+    internal static partial class CpuMathUtils
+    {
+        /// <summary>
+        /// Adds a value to a destination.
+        /// </summary>
+        /// <param name="value">The value to add.</param>
+        /// <param name="destination">The destination to add the value to.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Add(float value, Span<float> destination)
+        {
+            Contracts.AssertNonEmpty(destination);
+            TensorPrimitives.Add(destination, value, destination);
+        }
+
+        /// <summary>
+        /// Scales a value to a destination.
+        /// </summary>
+        /// <param name="value">The value to add.</param>
+        /// <param name="destination">The destination to add the value to.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Scale(float value, Span<float> destination)
+        {
+            Contracts.AssertNonEmpty(destination);
+            TensorPrimitives.Multiply(destination, value, destination);
+        }
+
+        /// <summary>
+        /// Scales a values by a source to a destination.
+        /// destination = value * source
+        /// </summary>
+        /// <param name="value">The value to scale by.</param>
+        /// <param name="source">The source values.</param>
+        /// <param name="destination">The destination.</param>
+        /// <param name="count">The count of items.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Scale(float value, ReadOnlySpan<float> source, Span<float> destination, int count)
+        {
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
+            Contracts.Assert(count > 0);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
+
+            TensorPrimitives.Multiply(source.Slice(0, count), value, destination);
+        }
+
+        /// <summary>
+        /// Add to the destination from the source by scale.
+        /// </summary>
+        /// <param name="scale">The scale to add by.</param>
+        /// <param name="source">The source values.</param>
+        /// <param name="destination">The destination values.</param>
+        /// <param name="count">The count of items.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void AddScale(float scale, ReadOnlySpan<float> source, Span<float> destination, int count)
+        {
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
+            Contracts.Assert(count > 0);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
+
+            TensorPrimitives.MultiplyAdd(source.Slice(0, count), scale, destination.Slice(0, count), destination);
+        }
+
+        /// <summary>
+        /// Add to the destination by scale and source into a new result.
+        /// </summary>
+        /// <param name="scale">The scale to add by.</param>
+        /// <param name="source">The source values.</param>
+        /// <param name="destination">The destination values.</param>
+        /// <param name="result">A new collection of values to be returned.</param>
+        /// <param name="count">The count of items.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void AddScaleCopy(float scale, ReadOnlySpan<float> source, ReadOnlySpan<float> destination, Span<float> result, int count)
+        {
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
+            Contracts.AssertNonEmpty(result);
+            Contracts.Assert(count > 0);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
+            Contracts.Assert(count <= result.Length);
+
+            TensorPrimitives.MultiplyAdd(source.Slice(0, count), scale, destination.Slice(0, count), result.Slice(0, count));
+        }
+
+        /// <summary>
+        /// Add from a source to a destination.
+        /// </summary>
+        /// <param name="source">The source values.</param>
+        /// <param name="destination">The destination values.</param>
+        /// <param name="count">The count of items.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Add(ReadOnlySpan<float> source, Span<float> destination, int count)
+        {
+            Contracts.AssertNonEmpty(source);
+            Contracts.AssertNonEmpty(destination);
+            Contracts.Assert(count > 0);
+            Contracts.Assert(count <= source.Length);
+            Contracts.Assert(count <= destination.Length);
+
+            TensorPrimitives.Add(source.Slice(0, count), destination.Slice(0, count), destination.Slice(0, count));
+        }
+
+        /// <summary>
+        /// Multiply each element with left and right elements.
+        /// </summary>
+        /// <param name="left">The left element.</param>
+        /// <param name="right">The right element.</param>
+        /// <param name="destination">The destination values.</param>
+        /// <param name="count">The count of items.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void MulElementWise(ReadOnlySpan<float> left, ReadOnlySpan<float> right, Span<float> destination, int count)
+        {
+            Contracts.AssertNonEmpty(left);
+            Contracts.AssertNonEmpty(right);
+            Contracts.AssertNonEmpty(destination);
+            Contracts.Assert(count > 0);
+            Contracts.Assert(count <= left.Length);
+            Contracts.Assert(count <= right.Length);
+            Contracts.Assert(count <= destination.Length);
+
+            TensorPrimitives.Multiply(left.Slice(0, count), right.Slice(0, count), destination.Slice(0, count));
+        }
+
+        /// <summary>
+        /// Sum the values in the source.
+        /// </summary>
+        /// <param name="source">The source values.</param>
+        /// <returns>The sum of all items in <paramref name="source"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float Sum(ReadOnlySpan<float> source)
+        {
+            Contracts.AssertNonEmpty(source);
+
+            return TensorPrimitives.Sum(source);
+        }
+
+        /// <summary>
+        /// Sum the squares of each item in the source.
+        /// </summary>
+        /// <param name="source">The source values.</param>
+        /// <returns>The sum of the squares of all items in <paramref name="source"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float SumSq(ReadOnlySpan<float> source)
+        {
+            Contracts.AssertNonEmpty(source);
+
+            return TensorPrimitives.SumOfSquares(source);
+        }
+
+        /// <summary>
+        /// Sum the absolute value of each item in the source.
+        /// </summary>
+        /// <param name="source">The source values.</param>
+        /// <returns>The sum of all absolute value of the items in <paramref name="source"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float SumAbs(ReadOnlySpan<float> source)
+        {
+            Contracts.AssertNonEmpty(source);
+
+            return TensorPrimitives.SumOfMagnitudes(source);
+        }
+
+        /// <summary>
+        /// Returns the dot product of each item in the left and right spans.
+        /// </summary>
+        /// <param name="left">The left span.</param>
+        /// <param name="right">The right span.</param>
+        /// <param name="count">The count of items.</param>
+        /// <returns>The dot product.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static float DotProductDense(ReadOnlySpan<float> left, ReadOnlySpan<float> right, int count)
+        {
+            Contracts.AssertNonEmpty(left);
+            Contracts.AssertNonEmpty(right);
+            Contracts.Assert(count > 0);
+            Contracts.Assert(left.Length >= count);
+            Contracts.Assert(right.Length >= count);
+
+            return TensorPrimitives.Dot(left.Slice(0, count), right.Slice(0, count));
+        }
+    }
+}