Speedup: method JIT, calls, blocks, exceptions and library fast paths

Build/dlr-patches/0100-compile-pipeline.patch

@@ -0,0 +1,59 @@
+diff --git a/src/core/Microsoft.Dynamic/Interpreter/Instructions/CallInstruction.cs b/src/core/Microsoft.Dynamic/Interpreter/Instructions/CallInstruction.cs
+index 3b7bbb5..a979b25 100644
+--- a/src/core/Microsoft.Dynamic/Interpreter/Instructions/CallInstruction.cs
++++ b/src/core/Microsoft.Dynamic/Interpreter/Instructions/CallInstruction.cs
+@@ -25,6 +25,19 @@ namespace Microsoft.Scripting.Interpreter {
+
+         private static readonly Dictionary<MethodInfo, CallInstruction> _cache = new();
+
++        /// <summary>
++        /// The instruction <see cref="Create(MethodInfo, ParameterInfo[])"/> made and cached for <paramref name="info"/>
++        /// before, if any. A method is cached only once it is known to need none of the special handling Create
++        /// checks for (array accessors, by-ref parameters, value-type instance methods, dynamic methods, too many
++        /// arguments), so a hit can skip GetParameters() - which copies the parameter array on every call - and
++        /// those checks altogether.
++        /// </summary>
++        internal static bool TryGetCached(MethodInfo info, out CallInstruction instruction) {
++            lock (_cache) {
++                return _cache.TryGetValue(info, out instruction);
++            }
++        }
++
+         /// <exception cref="SecurityException">Instruction can't be created due to insufficient privileges.</exception>
+         public static CallInstruction Create(MethodInfo info) {
+             return Create(info, info.GetParameters());
+diff --git a/src/core/Microsoft.Dynamic/Interpreter/LightCompiler.cs b/src/core/Microsoft.Dynamic/Interpreter/LightCompiler.cs
+index 457ec85..84b88f7 100644
+--- a/src/core/Microsoft.Dynamic/Interpreter/LightCompiler.cs
++++ b/src/core/Microsoft.Dynamic/Interpreter/LightCompiler.cs
+@@ -1153,6 +1153,19 @@ namespace Microsoft.Scripting.Interpreter {
+         private void CompileMethodCallExpression(Expression expr) {
+             var node = (MethodCallExpression)expr;
+
++            // A method compiled before has its instruction cached, which also says it takes no by-ref
++            // parameters and is not an instance method of a value type (see CallInstruction.TryGetCached).
++            if (CallInstruction.TryGetCached(node.Method, out CallInstruction cached)) {
++                if (!node.Method.IsStatic) {
++                    Compile(node.Object);
++                }
++                foreach (var arg in node.Arguments) {
++                    Compile(arg);
++                }
++                Instructions.Emit(cached);
++                return;
++            }
++
+             var parameters = node.Method.GetParameters();
+
+             // TODO:
+@@ -1180,6 +1193,10 @@ namespace Microsoft.Scripting.Interpreter {
+         }
+
+         public void EmitCall(MethodInfo method) {
++            if (CallInstruction.TryGetCached(method, out CallInstruction cached)) {
++                Instructions.Emit(cached);
++                return;
++            }
+             EmitCall(method, method.GetParameters());
+         }
+

Build/dlr-patches/0100-exceptions.patch

@@ -0,0 +1,168 @@
+diff --git a/src/core/Microsoft.Dynamic/Interpreter/InterpretedFrame.cs b/src/core/Microsoft.Dynamic/Interpreter/InterpretedFrame.cs
+index 1a32e58..0a97958 100644
+--- a/src/core/Microsoft.Dynamic/Interpreter/InterpretedFrame.cs
++++ b/src/core/Microsoft.Dynamic/Interpreter/InterpretedFrame.cs
+@@ -146,10 +146,26 @@ namespace Microsoft.Scripting.Interpreter {
+
+         internal void SaveTraceToException(Exception exception) {
+             if (exception.GetData(typeof(InterpretedFrameInfo)) is null) {
+-                exception.SetData(typeof(InterpretedFrameInfo), GetStackTraceDebugInfo().ToArray());
++                exception.SetData(typeof(InterpretedFrameInfo), GetStackTraceDebugInfoArray());
+             }
+         }
+
++        // GetStackTraceDebugInfo().ToArray() without the iterator and the list it grows: every
++        // exception that passes an interpreted frame takes this snapshot of the whole chain.
++        private InterpretedFrameInfo[] GetStackTraceDebugInfoArray() {
++            int count = 0;
++            for (var frame = this; frame is not null; frame = frame.Parent) {
++                count++;
++            }
++
++            var result = new InterpretedFrameInfo[count];
++            int i = 0;
++            for (var frame = this; frame is not null; frame = frame.Parent) {
++                result[i++] = new InterpretedFrameInfo(frame.Name, frame.GetDebugInfo(frame.InstructionIndex));
++            }
++            return result;
++        }
++
+         public static InterpretedFrameInfo[] GetExceptionStackTrace(Exception exception) {
+             return exception.GetData(typeof(InterpretedFrameInfo)) as InterpretedFrameInfo[];
+         }
+diff --git a/src/core/Microsoft.Dynamic/Utils/ExceptionUtils.cs b/src/core/Microsoft.Dynamic/Utils/ExceptionUtils.cs
+index 7176c59..047827a 100644
+--- a/src/core/Microsoft.Dynamic/Utils/ExceptionUtils.cs
++++ b/src/core/Microsoft.Dynamic/Utils/ExceptionUtils.cs
+@@ -30,6 +30,131 @@ namespace Microsoft.Scripting.Utils {
+         public static void RemoveData(this Exception e, object key) {
+             e.Data.Remove(key);
+         }
++#elif NETCOREAPP
++        // Exception.Data's dictionary, as on the desktop: languages attach data to every exception they
++        // see go by (the interpreter its frames, IronRuby its exception state), several times per raise.
++        // The ConditionalWeakTable below costs a dependent handle per exception, which every GC has to
++        // scan, and a global lock plus a LINQ scan per lookup. The dictionary is not thread-safe, hence
++        // the lock on it - uncontended in practice.
++        //
++        // The dictionary is reached through Exception's own field where the runtime has it: the Data
++        // property is virtual, and the subclasses a language generates for its own exception classes
++        // override every virtual member to dispatch to the language first (IronRuby's do), which made a
++        // Data lookup cost microseconds. An exception type whose Data is not writable gets the table.
++        public static object GetData(this Exception e, object key) {
++            var data = GetDictionary(e, false);
++            if (data is null) {
++                return _hasTableData ? GetTableData(e, key) : null;
++            }
++            lock (data) {
++                return data[key];
++            }
++        }
++
++        public static void SetData(this Exception e, object key, object value) {
++            var data = GetDictionary(e, true);
++            if (data is null) {
++                SetTableData(e, key, value);
++                return;
++            }
++            lock (data) {
++                data[key] = value;
++            }
++        }
++
++        public static void RemoveData(this Exception e, object key) {
++            var data = GetDictionary(e, false);
++            if (data is null) {
++                if (_hasTableData) {
++                    RemoveTableData(e, key);
++                }
++                return;
++            }
++            lock (data) {
++                data.Remove(key);
++            }
++        }
++
++        // null: no dictionary yet (and create is false), or one that cannot be written to
++        private static System.Collections.IDictionary GetDictionary(Exception e, bool create) {
++#if NET8_0_OR_GREATER
++            if (_dataFieldAvailable) {
++                try {
++                    ref System.Collections.IDictionary field = ref DataField(e);
++                    var dictionary = field;
++                    if (dictionary is null) {
++                        if (!create) {
++                            return null;
++                        }
++                        Interlocked.CompareExchange(ref field, new System.Collections.Specialized.ListDictionary(), null);
++                        dictionary = field;
++                    }
++                    return dictionary.IsReadOnly ? null : dictionary;
++                } catch (MissingFieldException) {
++                    _dataFieldAvailable = false;
++                }
++            }
++#endif
++            var data = e.Data;
++            return (data is null || data.IsReadOnly) ? null : data;
++        }
++
++#if NET8_0_OR_GREATER
++        [UnsafeAccessor(UnsafeAccessorKind.Field, Name = "_data")]
++        private static extern ref System.Collections.IDictionary DataField(Exception e);
++
++        private static bool _dataFieldAvailable = true;
++#endif
++
++        private static volatile bool _hasTableData;
++
++        private static ConditionalWeakTable<Exception, List<KeyValuePair<object, object>>> _exceptionData;
++
++        private static void SetTableData(Exception e, object key, object value) {
++            _hasTableData = true;
++            if (_exceptionData is null) {
++                Interlocked.CompareExchange(ref _exceptionData, new ConditionalWeakTable<Exception, List<KeyValuePair<object, object>>>(), null);
++            }
++
++            lock (_exceptionData) {
++                var data = _exceptionData.GetOrCreateValue(e);
++                int index = data.FindIndex(entry => entry.Key == key);
++                if (index >= 0) {
++                    data[index] = new KeyValuePair<object, object>(key, value);
++                } else {
++                    data.Add(new KeyValuePair<object, object>(key, value));
++                }
++            }
++        }
++
++        private static object GetTableData(Exception e, object key) {
++            if (_exceptionData is null) {
++                return null;
++            }
++
++            lock (_exceptionData) {
++                if (!_exceptionData.TryGetValue(e, out List<KeyValuePair<object, object>> data)) {
++                    return null;
++                }
++                return data.FirstOrDefault(entry => entry.Key == key).Value;
++            }
++        }
++
++        private static void RemoveTableData(Exception e, object key) {
++            if (_exceptionData is null) {
++                return;
++            }
++
++            lock (_exceptionData) {
++                if (!_exceptionData.TryGetValue(e, out List<KeyValuePair<object, object>> data)) {
++                    return;
++                }
++                int index = data.FindIndex(entry => entry.Key == key);
++                if (index >= 0) {
++                    data.RemoveAt(index);
++                }
++            }
++        }
+ #else
+         private static ConditionalWeakTable<Exception, List<KeyValuePair<object, object>>> _exceptionData;
+

Src/Libraries/Builtins/ArrayOps.cs

@@ -316,7 +316,9 @@ internal static RubyArray SortInPlace(ComparisonStorage/*!*/ comparisonStorage,
             var context = comparisonStorage.Context;
 
             if (block == null) {
-                MergeSort(self, (x, y) => Protocols.Compare(comparisonStorage, x, y));
+                if (!TrySortWithoutDispatch(context, self)) {
+                    MergeSort(self, (x, y) => Protocols.Compare(comparisonStorage, x, y));
+                }
             } else {
                 object nonRefBreakResult = null;
                 try {
@@ -343,6 +345,146 @@ internal static RubyArray SortInPlace(ComparisonStorage/*!*/ comparisonStorage,
             return self;
         }
 
+        /// <summary>
+        /// sort without a block over an array of only Strings, only Fixnums or only Floats (no NaN) - the
+        /// common case - compares the elements directly instead of dispatching #<=> for every pair, as
+        /// long as the class's #<=> is still the built-in one and no element is an instance of a
+        /// subclass or has a singleton class. The comparisons are the ones those #<=> make, so the
+        /// order is the same; anything else goes the general way.
+        /// </summary>
+        private static bool TrySortWithoutDispatch(RubyContext/*!*/ context, RubyArray/*!*/ self) {
+            int count = self.Count;
+            // (#<=> called from a C# sort ignores refinements, as rb_funcall does in MRI's sort)
+            if (count < 2) {
+                return false;
+            }
+
+            object first = self[0];
+            if (first != null && first.GetType() == typeof(MutableString)) {
+                var stringClass = context.GetClass(typeof(MutableString));
+                var keys = new StringKey[count];
+                for (int i = 0; i < count; i++) {
+                    object item = self[i];
+                    if (item == null || item.GetType() != typeof(MutableString) || context.GetImmediateClassOf(item) != stringClass) {
+                        return false;
+                    }
+                    keys[i] = new StringKey((MutableString)item);
+                }
+                if (!HasBuiltinComparison(stringClass)) {
+                    return false;
+                }
+                SortByKeys(self, keys);
+                return true;
+            }
+
+            if (first is int) {
+                var keys = new int[count];
+                for (int i = 0; i < count; i++) {
+                    object item = self[i];
+                    if (!(item is int)) {
+                        return false;
+                    }
+                    keys[i] = (int)item;
+                }
+                if (!HasBuiltinComparison(context.GetClassOf(first))) {
+                    return false;
+                }
+                SortByKeys(self, keys);
+                return true;
+            }
+
+            if (first is double) {
+                var keys = new double[count];
+                for (int i = 0; i < count; i++) {
+                    object item = self[i];
+                    if (!(item is double) || Double.IsNaN((double)item)) {
+                        return false;
+                    }
+                    keys[i] = (double)item;
+                }
+                if (!HasBuiltinComparison(context.GetClassOf(first))) {
+                    return false;
+                }
+                SortByKeys(self, keys);
+                return true;
+            }
+
+            return false;
+        }
+
+        // A struct, so that the generic sort below is compiled for it and calls MutableString.CompareTo
+        // directly; over the class itself it would share one body and dispatch every comparison.
+        private struct StringKey : IComparable<StringKey> {
+            private readonly MutableString/*!*/ _value;
+            public StringKey(MutableString/*!*/ value) { _value = value; }
+            public int CompareTo(StringKey other) { return _value.CompareTo(other._value); }
+        }
+
+        // The same stable merge sort as MergeSort, over keys of one type compared by their own CompareTo
+        // (what String#<=>, Integer#<=> and Float#<=> do for two of them), carrying the elements along.
+        private static void SortByKeys<TKey>(RubyArray/*!*/ self, TKey[]/*!*/ keys) where TKey : IComparable<TKey> {
+            int count = keys.Length;
+            object[] items = new object[count];
+            self.CopyTo(items, 0);
+            MergeSortKeys(keys, items, new TKey[count], new object[count], 0, count);
+            for (int i = 0; i < count; i++) {
+                self[i] = items[i];
+            }
+        }
+
+        private static void MergeSortKeys<TKey>(TKey[]/*!*/ keys, object[]/*!*/ items, TKey[]/*!*/ keyBuffer, object[]/*!*/ itemBuffer,
+            int start, int length) where TKey : IComparable<TKey> {
+
+            if (length <= 12) {
+                // insertion sort, stable: an element moves left only past strictly greater ones
+                for (int i = start + 1; i < start + length; i++) {
+                    TKey key = keys[i];
+                    object item = items[i];
+                    int j = i - 1;
+                    while (j >= start && key.CompareTo(keys[j]) < 0) {
+                        keys[j + 1] = keys[j];
+                        items[j + 1] = items[j];
+                        j--;
+                    }
+                    keys[j + 1] = key;
+                    items[j + 1] = item;
+                }
+                return;
+            }
+
+            int half = length / 2;
+            MergeSortKeys(keys, items, keyBuffer, itemBuffer, start, half);
+            MergeSortKeys(keys, items, keyBuffer, itemBuffer, start + half, length - half);
+
+            int left = start, right = start + half, target = start;
+            int leftEnd = start + half, rightEnd = start + length;
+            while (left < leftEnd && right < rightEnd) {
+                if (keys[right].CompareTo(keys[left]) < 0) {
+                    keyBuffer[target] = keys[right];
+                    itemBuffer[target++] = items[right++];
+                } else {
+                    keyBuffer[target] = keys[left];
+                    itemBuffer[target++] = items[left++];
+                }
+            }
+            while (left < leftEnd) {
+                keyBuffer[target] = keys[left];
+                itemBuffer[target++] = items[left++];
+            }
+            while (right < rightEnd) {
+                keyBuffer[target] = keys[right];
+                itemBuffer[target++] = items[right++];
+            }
+
+            Array.Copy(keyBuffer, start, keys, start, length);
+            Array.Copy(itemBuffer, start, items, start, length);
+        }
+
+        private static bool HasBuiltinComparison(RubyClass/*!*/ cls) {
+            var method = cls.ResolveMethod("<=>", VisibilityContext.AllVisible);
+            return method.Found && method.Info is RubyLibraryMethodInfo;
+        }
+
         /// <summary>
         /// List&lt;T&gt;.Sort cannot be used here: it wraps whatever the comparer throws in an
         /// InvalidOperationException (so a Ruby exception or a block's break never arrives