Reduce allocations observed in local trace opening Roslyn.sln

azure-pipelines-integration-corehost.yml

@@ -59,7 +59,7 @@ parameters:
 - name: queueName
   displayName: Queue Name
   type: string
-  default: windows.vs2022preview.amd64.open
+  default: windows.vs2022preview.scout.amd64.open
   values:
   - windows.vs2022.amd64.open
   - windows.vs2022.scout.amd64.open

src/Compilers/CSharp/Portable/Symbols/TypeSymbolExtensions.cs

@@ -7,6 +7,7 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
 using System.Text;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Roslyn.Utilities;
@@ -606,11 +607,18 @@ public static SpecialType GetSpecialTypeSafe(this TypeSymbol? type)
             return type is object ? type.SpecialType : SpecialType.None;
         }
 
-        public static bool IsAtLeastAsVisibleAs(this TypeSymbol type, Symbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
+        public static unsafe bool IsAtLeastAsVisibleAs(this TypeSymbol type, Symbol sym, ref CompoundUseSiteInfo<AssemblySymbol> useSiteInfo)
         {
             CompoundUseSiteInfo<AssemblySymbol> localUseSiteInfo = useSiteInfo;
-            var result = type.VisitType((type1, symbol, unused) => IsTypeLessVisibleThan(type1, symbol, ref localUseSiteInfo), sym,
-                                        canDigThroughNullable: true); // System.Nullable is public
+            var localUseSiteInfoPtr = (nint)Unsafe.AsPointer(ref localUseSiteInfo);
+            var result = type.VisitType(
+                static (type1, arg, _) =>
+                {
+                    ref var localUseSiteInfo = ref Unsafe.AsRef<CompoundUseSiteInfo<AssemblySymbol>>((void*)arg.localUseSiteInfoPtr);
+                    return IsTypeLessVisibleThan(type1, arg.sym, ref localUseSiteInfo);
+                },
+                (sym, localUseSiteInfoPtr),
+                canDigThroughNullable: true); // System.Nullable is public
             useSiteInfo = localUseSiteInfo;
             return result is null;
         }

src/Compilers/Core/Portable/InternalUtilities/EnumerableExtensions.cs

@@ -608,7 +608,7 @@ public static ImmutableDictionary<K, V> ToImmutableDictionaryOrEmpty<K, V>(this
                 return ImmutableDictionary.Create<K, V>(keyComparer);
             }
 
-            return ImmutableDictionary.CreateRange(keyComparer, items);
+            return items.ToImmutableDictionary(keyComparer);
         }
 
 #nullable disable // Transpose doesn't handle empty arrays. Needs to be updated as appropriate.

src/Compilers/Core/Portable/PEWriter/FullMetadataWriter.cs

@@ -9,6 +9,7 @@
 using System.Reflection.Metadata.Ecma335;
 using System.Threading;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Collections;
 using Microsoft.CodeAnalysis.Emit;
 using Roslyn.Utilities;
 using EmitContext = Microsoft.CodeAnalysis.Emit.EmitContext;
@@ -28,7 +29,7 @@ internal sealed class FullMetadataWriter : MetadataWriter
 
         private readonly Dictionary<ITypeDefinition, int> _fieldDefIndex;
         private readonly Dictionary<ITypeDefinition, int> _methodDefIndex;
-        private readonly Dictionary<IMethodDefinition, int> _parameterListIndex;
+        private readonly SegmentedDictionary<IMethodDefinition, int> _parameterListIndex;
 
         private readonly HeapOrReferenceIndex<AssemblyIdentity> _assemblyRefIndex;
         private readonly HeapOrReferenceIndex<string> _moduleRefIndex;
@@ -101,7 +102,7 @@ private FullMetadataWriter(
 
             _fieldDefIndex = new Dictionary<ITypeDefinition, int>(numTypeDefsGuess, ReferenceEqualityComparer.Instance);
             _methodDefIndex = new Dictionary<ITypeDefinition, int>(numTypeDefsGuess, ReferenceEqualityComparer.Instance);
-            _parameterListIndex = new Dictionary<IMethodDefinition, int>(numMethods, ReferenceEqualityComparer.Instance);
+            _parameterListIndex = new SegmentedDictionary<IMethodDefinition, int>(numMethods, ReferenceEqualityComparer.Instance);
 
             _assemblyRefIndex = new HeapOrReferenceIndex<AssemblyIdentity>(this);
             _moduleRefIndex = new HeapOrReferenceIndex<string>(this);
@@ -430,13 +431,13 @@ private void CreateIndicesFor(IMethodDefinition methodDef)
         private readonly struct DefinitionIndex<T> where T : class, IReference
         {
             // IReference to RowId
-            private readonly Dictionary<T, int> _index;
-            private readonly List<T> _rows;
+            private readonly SegmentedDictionary<T, int> _index;
+            private readonly SegmentedList<T> _rows;
 
             public DefinitionIndex(int capacity)
             {
-                _index = new Dictionary<T, int>(capacity, ReferenceEqualityComparer.Instance);
-                _rows = new List<T>(capacity);
+                _index = new SegmentedDictionary<T, int>(capacity, ReferenceEqualityComparer.Instance);
+                _rows = new SegmentedList<T>(capacity);
             }
 
             public bool TryGetValue(T item, out int rowId)

src/Compilers/Core/Portable/PEWriter/MetadataWriter.cs

@@ -106,7 +106,7 @@ protected MetadataWriter(
 
             // EDMAURER provide some reasonable size estimates for these that will avoid
             // much of the reallocation that would occur when growing these from empty.
-            _signatureIndex = new Dictionary<ISignature, KeyValuePair<BlobHandle, ImmutableArray<byte>>>(module.HintNumberOfMethodDefinitions, ReferenceEqualityComparer.Instance); //ignores field signatures
+            _signatureIndex = new SegmentedDictionary<ISignature, KeyValuePair<BlobHandle, ImmutableArray<byte>>>(module.HintNumberOfMethodDefinitions, ReferenceEqualityComparer.Instance); //ignores field signatures
 
             this.Context = context;
             this.messageProvider = messageProvider;
@@ -431,14 +431,14 @@ private bool IsMinimalDelta
 
         private readonly DynamicAnalysisDataWriter _dynamicAnalysisDataWriterOpt;
 
-        private readonly Dictionary<ICustomAttribute, BlobHandle> _customAttributeSignatureIndex = new Dictionary<ICustomAttribute, BlobHandle>();
+        private readonly SegmentedDictionary<ICustomAttribute, BlobHandle> _customAttributeSignatureIndex = new SegmentedDictionary<ICustomAttribute, BlobHandle>();
         private readonly Dictionary<ITypeReference, BlobHandle> _typeSpecSignatureIndex = new Dictionary<ITypeReference, BlobHandle>(ReferenceEqualityComparer.Instance);
         private readonly Dictionary<string, int> _fileRefIndex = new Dictionary<string, int>(32);  // more than enough in most cases, value is a RowId
         private readonly List<IFileReference> _fileRefList = new List<IFileReference>(32);
-        private readonly Dictionary<IFieldReference, BlobHandle> _fieldSignatureIndex = new Dictionary<IFieldReference, BlobHandle>(ReferenceEqualityComparer.Instance);
+        private readonly SegmentedDictionary<IFieldReference, BlobHandle> _fieldSignatureIndex = new SegmentedDictionary<IFieldReference, BlobHandle>(ReferenceEqualityComparer.Instance);
 
         // We need to keep track of both the index of the signature and the actual blob to support VB static local naming scheme.
-        private readonly Dictionary<ISignature, KeyValuePair<BlobHandle, ImmutableArray<byte>>> _signatureIndex;
+        private readonly SegmentedDictionary<ISignature, KeyValuePair<BlobHandle, ImmutableArray<byte>>> _signatureIndex;
 
         private readonly Dictionary<IMarshallingInformation, BlobHandle> _marshallingDescriptorIndex = new Dictionary<IMarshallingInformation, BlobHandle>();
         protected readonly List<MethodImplementation> methodImplList = new List<MethodImplementation>();

src/Compilers/VisualBasic/Portable/Compilation/VisualBasicDiagnosticFilter.vb

@@ -33,8 +33,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic
             cancellationToken As CancellationToken) As Diagnostic
 
             ' Diagnostic ids must be processed in case-insensitive fashion in VB.
-            Dim caseInsensitiveSpecificDiagnosticOptions =
-            ImmutableDictionary.Create(Of String, ReportDiagnostic)(CaseInsensitiveComparison.Comparer).AddRange(specificDiagnosticOptions)
+            Dim caseInsensitiveSpecificDiagnosticOptions = specificDiagnosticOptions.ToImmutableDictionary(CaseInsensitiveComparison.Comparer)
 
             ' Filter void diagnostics so that our callers don't have to perform resolution
             ' (which might copy the list of diagnostics).

src/Tools/Source/CompilerGeneratorTools/Source/CSharpSyntaxGenerator/AbstractFileWriter.cs

@@ -21,6 +21,8 @@ internal abstract class AbstractFileWriter
 
         private readonly IDictionary<string, Node> _nodeMap;
         private readonly IDictionary<string, TreeType> _typeMap;
+        private readonly Dictionary<string, string> _camelCaseMap = new(StringComparer.Ordinal);
+        private readonly List<string> _indentMap = new();
 
         private const int INDENT_SIZE = 4;
         private int _indentLevel;
@@ -94,7 +96,12 @@ private void WriteIndentIfNeeded()
         {
             if (_needIndent)
             {
-                _writer.Write(new string(' ', _indentLevel * INDENT_SIZE));
+                while (_indentMap.Count <= _indentLevel)
+                {
+                    _indentMap.Add(new string(' ', _indentMap.Count * INDENT_SIZE));
+                }
+
+                _writer.Write(_indentMap[_indentLevel]);
                 _needIndent = false;
             }
         }
@@ -260,13 +267,23 @@ protected static bool HasErrors(Node n)
             return n.Errors == null || string.Compare(n.Errors, "true", true) == 0;
         }
 
-        protected static string CamelCase(string name)
+        protected string CamelCase(string name)
         {
+            if (_camelCaseMap.TryGetValue(name, out var camelCase))
+                return camelCase;
+
             if (char.IsUpper(name[0]))
             {
-                name = char.ToLowerInvariant(name[0]) + name.Substring(1);
+                camelCase = char.ToLowerInvariant(name[0]) + name.Substring(1);
             }
-            return FixKeyword(name);
+            else
+            {
+                camelCase = name;
+            }
+
+            camelCase = FixKeyword(camelCase);
+            _camelCaseMap.Add(name, camelCase);
+            return camelCase;
         }
 
         protected static string FixKeyword(string name)