Bug Report

commit sha fd36740ef3523b4aa40423fa575fb93a5f2bcdd9

Add AbstractEnumCompletionProvider

commit sha 01f3dcce4002959793b6a28108b2d45d8c33f1aa

Move GetPreselectedSymbolsAsync to AbstractEnumCompletionProvider

commit sha 07d8ee1b8bb643d8dbc6b60ee4408f6c926464d3

Move GetSymbolsAsync to AbstractEnumCompletionProvider

commit sha 1dc6293c4e2141655993976aa700c84e44f6f387

Move GetDisplayAndSuffixAndInsertionText to AbstractEnumCompletionProvider

commit sha 495d5ace47c9dbf085048bb80f93aea93876a0ba

Move CreateItem to AbstractEnumCompletionProvider

commit sha e8376311d7d8bf3e6f4f3d71541333885884c84d

Move GetTextChangeAsync to AbstractEnumCompletionProvider

commit sha 9595681b4edb203b703b37e46581a9a0b53dda03

Bring "IsSkippedTokensTrivia" check back to AbstractEnumCompletionProvider (but I think the IsSkippedTokensTrivia extension method is buggy)

commit sha 2d95d06441b632761357e43deebd4e313f856277

Add EnumCompletionProvider

commit sha 284e17d738aada1932dea9b825ba178461087ed8

Fix completion provider order

commit sha d6d29ddcd4e5ec5ed7937cf6ee8bd3c273b7cd9c

Format EnumCompletionProvider.cs

commit sha d4573735c00454100a9b2a1044b4b0b5a1e3652f

Format AbstractEnumCompletionProvider

commit sha 24b293b9b86eb22fc13a31cbf35a4cf16da20547

Format EnumCompletionProvider.vb

commit sha 70ff8066c8e8cc5430e3ab5b6bfe1ef0d416a2ef

Fix syntax error in EnumCompletionProviderTests (VB)

commit sha d7d76c8065d72a18af82f1b7ea76954c7b0e30fd

Convert (most) test cases from VB to C#

commit sha bf139a33241b6844e8b88621f16a80da9ca435e4

Fix TestTriggeredForNamedArgument

commit sha 12b0f6bdf2532424f87a0194a6c38f9f7b3eebf7

Add TestNotInTrivia

commit sha c2c50f8487229995ca52c54fa732e2df1b225ebd

Apply suggestions from code review Co-authored-by: CyrusNajmabadi <cyrus.najmabadi@gmail.com>

commit sha 3277eac8507ab3513778eed33c47c21c51c13d64

Fix compiler error after code review

commit sha fa0f1d6b86bea259bbed2f1c379a932d487d2d0b

Fix stackoverflow in EnumCompletionProvider.vb GetDefaultDisplayAndSuffixAndInsertionText

commit sha 8937b29358294f363f34790740fbfe4bbf05bf11

Remove unused variable.

Cannot Submit Xaml Island App to Microsoft Store

push time in 4 minutes

PR merged dotnet/roslyn

Enum values completion provider for C# Area-IDE Community

Fixes #47193

xu1IxT2zZ1

This PR basically brings the VB version of the enum values provider to C# by moving the existing logic to AbstractEnumCompletionProvider.

+1125 -84

67 commit in MaStr11/roslyn/tree/EnumValuesCompletionProvider dotnet/roslyn/tree/release/dev16.10

15 comments

7 changed files

MaStr11

pr closed time in 4 minutes

issue commentmicrosoft/microsoft-ui-xaml

@michalleptuch, yes I resolved it by adding the reference xaml island project into the installer project.

jindal1979

comment created time in 7 minutes

pull request commentmicrosoft/onnxruntime

Assertion failed 'paddingToAdd == paddingNeeded'

The PR looks good to me except the CPU Execution Provider usage. Thanks a lot for adding tons of distributed test cases for both ZeRO + Megatron. This is awesome!

ashbhandare

comment created time in 8 minutes

issue commentdotnet/runtime

C:\h\w\A4CC08D0\w\AFD5092E\e>"C:\h\w\A4CC08D0\p\dotnet.exe" exec --runtimeconfig System.Collections.Tests.runtimeconfig.json --depsfile System.Collections.Tests.deps.json xunit.console.dll System.Collections.Tests.dll -xml testResults.xml -nologo -nocolor -notrait category=IgnoreForCI -notrait category=OuterLoop -notrait category=failing  
  Discovering: System.Collections.Tests (method display = ClassAndMethod, method display options = None)
  Discovered:  System.Collections.Tests (found 5129 of 6996 test cases)
  Starting:    System.Collections.Tests (parallel test collections = on, max threads = 4)

Assert failure(PID 4600 [0x000011f8], Thread: 5480 [0x1568]): Assertion failed 'paddingToAdd == paddingNeeded' in 'System.Collections.Tests.LinkedList_Generic_Tests`1[Int32][System.Int32]:AddFirst_T_Tests():this' during 'Emit code' (IL size 758)

    File: F:\workspace\_work\1\s\src\coreclr\jit\emitxarch.cpp Line: 9417
    Image: C:\h\w\A4CC08D0\p\dotnet.exe

----- end Sun 01/17/2021  8:02:11.25 ----- exit code -1073740286 ----------------------------------------------------------

https://helixre8s23ayyeko0k025g8.blob.core.windows.net/dotnet-runtime-refs-heads-master-a7ab659486744286af/System.Collections.Tests/console.8126f33e.log?sv=2019-07-07&se=2021-02-06T07%3A44%3A02Z&sr=c&sp=rl&sig=%2B3OjyHflp76my8yr6R5LOnyMZhn8z1g97ZEJjIiyqxE%3D

VincentBu

comment created time in 11 minutes

issue commentmicrosoft/TypeScript

Extending the system Error class does not work when transpiling to ES5

For reference, this is how Babel transpiles the above snippet:

"use strict";

function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }

function _construct(Parent, args, Class) { if (_isNativeReflectConstruct()) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Function.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }

function _isNativeFunction(fn) { return Function.toString.call(fn).indexOf("[native code]") !== -1; }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

var FooError = /*#__PURE__*/function (_Error) {
  _inherits(FooError, _Error);

  var _super = _createSuper(FooError);

  function FooError(m) {
    var _this;

    _classCallCheck(this, FooError);

    _this = _super.call(this, m); // Set the prototype explicitly.

    Object.setPrototypeOf(_assertThisInitialized(_this), FooError.prototype);
    return _this;
  }

  return FooError;
}( /*#__PURE__*/_wrapNativeSuper(Error));

octogonz

comment created time in 14 minutes

issue openedmicrosoft/TypeScript

Extending the system Error class does not work when transpiling to ES5

Bug Report

The system Error class cannot be extended without calling Object.setPrototypeOf() as a workaround, like this:

class FooError extends Error {
    constructor(m: string) {
        super(m);

        // Set the prototype explicitly.
        Object.setPrototypeOf(this, FooError.prototype);
    }
}

The TypeScript 2.1 release notes imply that this behavior is by design.

However when I proposed to add this workaround to the ANTLR4 runtime library, they observed that Babel injects the workaround automatically. Thus they concluded that this is a TypeScript bug rather than a problem with their library.

Is there some reason why TypeScript's transpiler cannot use the same solution as Babel?

🔎 Search Terms

setPrototypeOf extends Error

🕗 Version & Regression Information

Repros in TypeScript 4.1.3, first introduced in TypeScript 2.1.0

created time in 15 minutes

Pull request review commentmicrosoft/onnxruntime

Corrupt binlogs recorded on Linux using GZipStream

 def _create_ort_training_session(self, optimizer_state_dict={}):                     else:                         raise ValueError("Optimizer attributes must be either float or int.") +        self.options.distributed.horizontal_parallel_size = max(self.options.distributed.horizontal_parallel_size, 1)+        self.options.distributed.data_parallel_size = int(self.options.distributed.world_size/self.options.distributed.horizontal_parallel_size)

you can use //, then don't need int cast.

ashbhandare

comment created time in 20 minutes

issue commentdotnet/runtime

Binlogs uploaded by Tom are on corpnet at: kirillo2\public\Bugs\runtime47024

KirillOsenkov

comment created time in 23 minutes

PR closed Azure/azure-sdk-for-net

Reviewers

Supporting Availability set property in Azure Site Recovery for Vmware to Azure and Hyper V to Azure scenarios

+24 -6

2 commit in AsrOneSdk/azure-sdk-for-net/tree/user/vijami/avSetChanges Azure/azure-sdk-for-net/tree/master

0 comment

5 changed files

vidyadharijami

pr closed time in 26 minutes

issue openedmicrosoft/vscode

Can't install vscode extensions

VSCode Version: 1.52
OS Version: 20H2,19042, widows 10,

When ever i try to install python or jupyter extensions, it shows an error. "[renderer1] [error] EPERM: operation not permitted, lstat 'c:\Users\ai.vscode\extensions.ms-toolsai.jupyter-2020.12.414227025\out\client\node_modules\zeromq\prebuilds\win32-x64\electron.napi.node': deleting: EPERM: operation not permitted, lstat 'c:\Users\ai.vscode\extensions.ms-toolsai.jupyter-2020.12."

Does this issue occur when all extensions are disabled?: Yes

created time in 26 minutes

issue commentmicrosoft/vscode

Support multi cell selection in notebook

@claudiaregio they'd still appear on hover and whatever actions are taken there would apply for the selected cells. We'd only want to show actions that can be performed in bulk.

rebornix

comment created time in 29 minutes

PR closed chartjs/Chart.js

Add default export to esm build to make date adapters work

I'm currently getting:

WARNING in node_modules/chartjs-adapter-luxon/dist/chartjs-adapter-luxon.esm.js 23:0-5 "export 'default' (imported as 'Chart') was not found in 'chart.js'

The two choices here would be to add the default export here or to publish beta versions of the date adapters that use the named export

+4 -0

1 commit in benmccann/Chart.js/tree/default-export chartjs/Chart.js/tree/master

1 comment

1 changed file

benmccann

pr closed time in 30 minutes

pull request commentchartjs/Chart.js

Add default export to esm build to make date adapters work

Hmm. Actually if I downgrade chart-adapter-luxon it works again, so maybe this isn't necessary

benmccann

comment created time in 30 minutes

Pull request review commentdotnet/runtime

Improve Random (performance, APIs, ...)

 // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. +using System.Diagnostics;+using System.Numerics;+using System.Runtime.InteropServices;+ namespace System {+    /// <summary>+    /// Represents a pseudo-random number generator, which is an algorithm that produces a sequence of numbers+    /// that meet certain statistical requirements for randomness.+    /// </summary>     public class Random     {-        private static readonly Random s_globalRandom = new Random(GenerateGlobalSeed());-        [ThreadStatic]-        private static Random? t_threadRandom;+        /// <summary>The underlying generator implementation.</summary>+        /// <remarks>+        /// This is separated out so that different generators can be used based on how this Random instance is constructed.+        /// If it's built from a seed, then we may need to ensure backwards compatibility for folks expecting consistent sequences+        /// based on that seed.  If the instance is actually derived from Random, then we need to ensure the derived type's+        /// overrides are called anywhere they were being called previously.  But if the instance is the base type and is constructed+        /// with the default constructor, we have a lot of flexibility as to how to optimize the performance and quality of the generator.+        /// </remarks>+        private readonly ImplBase _impl;++        /// <summary>Initializes a new instance of the <see cref="Random"/> class using a default seed value.</summary>+        public Random() =>+            // With no seed specified, if this is the base type, we can implement this however we like.+            // If it's a derived type, for compat we respect the previous implementation.+            _impl = GetType() == typeof(Random) ?+                new Xoshiro256StarStarImpl() :+                new LegacyImpl(this);++        /// <summary>Initializes a new instance of the Random class, using the specified seed value.</summary>+        /// <param name="Seed">+        /// A number used to calculate a starting value for the pseudo-random number sequence. If a negative number+        /// is specified, the absolute value of the number is used.+        /// </param>+        public Random(int Seed) =>+            // With a custom seed, for compat we respect the previous implementation.+            _impl = new LegacyImpl(this, Seed);++        /// <summary>Returns a non-negative random integer.</summary>+        /// <returns>A 32-bit signed integer that is greater than or equal to 0 and less than <see cref="int.MaxValue"/>.</returns>+        public virtual int Next() => _impl.Next();++        /// <summary>Returns a non-negative random integer that is less than the specified maximum.</summary>+        /// <param name="maxValue">The exclusive upper bound of the random number to be generated. <paramref name="maxValue"/> must be greater than or equal to 0.</param>+        /// <returns>+        /// A 32-bit signed integer that is greater than or equal to 0, and less than <paramref name="maxValue"/>; that is, the range of return values ordinarily+        /// includes 0 but not <paramref name="maxValue"/>. However, if <paramref name="maxValue"/> equals 0, <paramref name="maxValue"/> is returned.+        /// </returns>+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxValue"/> is less than 0.</exception>+        public virtual int Next(int maxValue)+        {+            if (maxValue > 1)+            {+                return _impl.Next(maxValue);+            } -        private readonly int[] _seedArray = new int[56];-        private int _inext;-        private int _inextp;+            if (maxValue < 0)+            {+                ThrowMaxValueMustBeNonNegative();+            } -        public Random() : this(ThreadStaticRandom.Next())-        {+            Debug.Assert(maxValue == 0 || maxValue == 1);+            return 0;         } -        public Random(int Seed)+        /// <summary>Returns a random integer that is within a specified range.</summary>+        /// <param name="minValue">The inclusive lower bound of the random number returned.</param>+        /// <param name="maxValue">The exclusive upper bound of the random number returned. <paramref name="maxValue"/> must be greater than or equal to <paramref name="minValue"/>.</param>+        /// <returns>+        /// A 32-bit signed integer greater than or equal to <paramref name="minValue"/> and less than <paramref name="maxValue"/>; that is, the range of return values includes <paramref name="minValue"/>+        /// but not <paramref name="maxValue"/>. If minValue equals <paramref name="maxValue"/>, <paramref name="minValue"/> is returned.+        /// </returns>+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="minValue"/> is greater than <paramref name="maxValue"/>.</exception>+        public virtual int Next(int minValue, int maxValue)         {-            // Initialize seed array.--            int subtraction = (Seed == int.MinValue) ? int.MaxValue : Math.Abs(Seed);-            int mj = 161803398 - subtraction; // magic number based on Phi (golden ratio)-            _seedArray[55] = mj;-            int mk = 1;--            int ii = 0;-            for (int i = 1; i < 55; i++)+            if (maxValue > minValue)             {-                // The range [1..55] is special (Knuth) and so we're wasting the 0'th position.-                if ((ii += 21) >= 55)-                {-                    ii -= 55;-                }--                _seedArray[ii] = mk;-                mk = mj - mk;-                if (mk < 0)-                {-                    mk += int.MaxValue;-                }--                mj = _seedArray[ii];+                return _impl.Next(minValue, maxValue);             } -            for (int k = 1; k < 5; k++)+            if (minValue > maxValue)             {-                for (int i = 1; i < 56; i++)-                {-                    int n = i + 30;-                    if (n >= 55)-                    {-                        n -= 55;-                    }--                    _seedArray[i] -= _seedArray[1 + n];-                    if (_seedArray[i] < 0)-                    {-                        _seedArray[i] += int.MaxValue;-                    }-                }+                ThrowMinMaxValueSwapped();             } -            _inextp = 21;+            Debug.Assert(minValue == maxValue);+            return minValue;         } -        protected virtual double Sample() =>-            // Including the division at the end gives us significantly improved random number distribution.-            InternalSample() * (1.0 / int.MaxValue);--        public virtual int Next() => InternalSample();--        public virtual int Next(int maxValue)+        /// <summary>Returns a non-negative random integer.</summary>+        /// <returns>A 64-bit signed integer that is greater than or equal to 0 and less than <see cref="long.MaxValue"/>.</returns>+        public virtual long NextInt64() => _impl.NextInt64();++        /// <summary>Returns a non-negative random integer that is less than the specified maximum.</summary>+        /// <param name="maxValue">The exclusive upper bound of the random number to be generated. <paramref name="maxValue"/> must be greater than or equal to 0.</param>+        /// <returns>+        /// A 64-bit signed integer that is greater than or equal to 0, and less than <paramref name="maxValue"/>; that is, the range of return values ordinarily+        /// includes 0 but not <paramref name="maxValue"/>. However, if <paramref name="maxValue"/> equals 0, <paramref name="maxValue"/> is returned.+        /// </returns>+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="maxValue"/> is less than 0.</exception>+        public virtual long NextInt64(long maxValue)         {+            if (maxValue > 1)+            {+                return _impl.NextInt64(maxValue);+            }+             if (maxValue < 0)             {-                throw new ArgumentOutOfRangeException(nameof(maxValue), SR.Format(SR.ArgumentOutOfRange_MustBePositive, nameof(maxValue)));+                ThrowMaxValueMustBeNonNegative();             } -            return (int)(Sample() * maxValue);+            Debug.Assert(maxValue == 0 || maxValue == 1);+            return 0;         } -        public virtual int Next(int minValue, int maxValue)+        /// <summary>Returns a random integer that is within a specified range.</summary>+        /// <param name="minValue">The inclusive lower bound of the random number returned.</param>+        /// <param name="maxValue">The exclusive upper bound of the random number returned. <paramref name="maxValue"/> must be greater than or equal to <paramref name="minValue"/>.</param>+        /// <returns>+        /// A 64-bit signed integer greater than or equal to <paramref name="minValue"/> and less than <paramref name="maxValue"/>; that is, the range of return values includes <paramref name="minValue"/>+        /// but not <paramref name="maxValue"/>. If minValue equals <paramref name="maxValue"/>, <paramref name="minValue"/> is returned.+        /// </returns>+        /// <exception cref="ArgumentOutOfRangeException"><paramref name="minValue"/> is greater than <paramref name="maxValue"/>.</exception>+        public virtual long NextInt64(long minValue, long maxValue)         {+            if (maxValue > minValue)+            {+                return _impl.NextInt64(minValue, maxValue);+            }+             if (minValue > maxValue)             {-                throw new ArgumentOutOfRangeException(nameof(minValue), SR.Format(SR.Argument_MinMaxValue, nameof(minValue), nameof(maxValue)));+                ThrowMinMaxValueSwapped();             } -            long range = (long)maxValue - minValue;-            return range <= int.MaxValue ?-                (int)(Sample() * range) + minValue :-                (int)((long)(GetSampleForLargeRange() * range) + minValue);+            Debug.Assert(minValue == maxValue);+            return minValue;         } -        public virtual double NextDouble() => Sample();+        /// <summary>Returns a random floating-point number that is greater than or equal to 0.0, and less than 1.0.</summary>+        /// <returns>A single-precision floating point number that is greater than or equal to 0.0, and less than 1.0.</returns>+        public virtual float NextSingle() => _impl.NextSingle(); +        /// <summary>Returns a random floating-point number that is greater than or equal to 0.0, and less than 1.0.</summary>+        /// <returns>A double-precision floating point number that is greater than or equal to 0.0, and less than 1.0.</returns>+        public virtual double NextDouble() => _impl.NextDouble();++        /// <summary>Fills the elements of a specified array of bytes with random numbers.</summary>+        /// <param name="buffer">The array to be filled with random numbers.</param>+        /// <exception cref="ArgumentNullException"><paramref name="buffer"/> is null.</exception>         public virtual void NextBytes(byte[] buffer)         {             if (buffer is null)             {                 ThrowHelper.ThrowArgumentNullException(ExceptionArgument.buffer);             } -            for (int i = 0; i < buffer.Length; i++)-            {-                buffer[i] = (byte)InternalSample();-            }+            _impl.NextBytes(buffer);         } -        public virtual void NextBytes(Span<byte> buffer)+        /// <summary>Fills the elements of a specified span of bytes with random numbers.</summary>+        /// <param name="buffer">The array to be filled with random numbers.</param>+        public virtual void NextBytes(Span<byte> buffer) => _impl.NextBytes(buffer);++        /// <summary>Returns a random floating-point number between 0.0 and 1.0.</summary>+        /// <returns>A double-precision floating point number that is greater than or equal to 0.0, and less than 1.0.</returns>+        protected virtual double Sample() => _impl.Sample();++        private static void ThrowMinMaxValueSwapped() =>+            throw new ArgumentOutOfRangeException("minValue", SR.Format(SR.Argument_MinMaxValue, "minValue", "maxValue"));++        private static void ThrowMaxValueMustBeNonNegative() =>+            throw new ArgumentOutOfRangeException("maxValue", SR.Format(SR.ArgumentOutOfRange_NeedNonNegNum, "maxValue"));++        /// <summary>Base type for all generator implementations that plug into the base Random.</summary>+        private abstract class ImplBase

Why not interface? Any opportunity to share some code?

stephentoub

comment created time in 31 minutes

issue commentmicrosoft/vscode

Add options to right-click menu for untitled files to save it

I don't mind adding a save action in the context menu, though I'm not sure if that will help for those that don't know you can right-click on tabs. I like the idea of a scrapbook concept, kinda like saving everything to a "untitled" workspace that the user never has to manage (like codepen).

Another idea, what if we showed a codelens that asked the user to choose a language mode on empty untitled files? Then we could prompt a save afterwards:

sana-ajani

comment created time in 32 minutes

Pull request review commentmicrosoft/onnxruntime

System.Diagnostics.PerformanceCounter.Tests failure

 class TrainingSession : public InferenceSession {    * Partition information of each paritioned weight    */   struct PartitionInfo {+    // value of the original shape of the weight

One thing we should think earlier，probabbly not now, for a bit later is: we will make change to the naming or this schema of weight partition information, once it goes to more stable, we need some flags to control old logic parsing/aggregation ckpts I guess. What we can do currently is, to be aware of this possibility, and try to make it stable as early as possible.

ashbhandare

comment created time in 32 minutes

issue commentdotnet/runtime

Seems indeed to be fixed by the repaving.

ManickaP

comment created time in 38 minutes

Pull request review commentmicrosoft/onnxruntime