Add ability for crossgen2 to synthesize PGO histograms

src/coreclr/tools/Common/JitInterface/CorInfoImpl.cs

@@ -30,6 +30,8 @@
 using ILCompiler.DependencyAnalysis.ReadyToRun;
 #endif
 
+using DependencyList = ILCompiler.DependencyAnalysisFramework.DependencyNodeCore<ILCompiler.DependencyAnalysis.NodeFactory>.DependencyList;
+
 #pragma warning disable IDE0060
 
 namespace Internal.JitInterface
@@ -556,10 +558,15 @@ private void PublishCode()
                     }
                 }
             }
+
+            if (_synthesizedPgoDependencies != null)
+            {
+                Debug.Assert(_compilation.NodeFactory.InstrumentationDataTable != null, "Expected InstrumentationDataTable to be non-null with synthesized PGO data to embed");
+                _compilation.NodeFactory.InstrumentationDataTable.EmbedSynthesizedPgoDataForMethods(ref _additionalDependencies, _synthesizedPgoDependencies);
+            }
 #else
             var methodIL = (MethodIL)HandleToObject((void*)_methodScope);
             CodeBasedDependencyAlgorithm.AddDependenciesDueToMethodCodePresence(ref _additionalDependencies, _compilation.NodeFactory, MethodBeingCompiled, methodIL);
-            _methodCodeNode.InitializeNonRelocationDependencies(_additionalDependencies);
             _methodCodeNode.InitializeDebugInfo(_debugInfo);
 
             LocalVariableDefinition[] locals = methodIL.GetLocals();
@@ -569,6 +576,8 @@ private void PublishCode()
 
             _methodCodeNode.InitializeLocalTypes(localTypes);
 #endif
+
+            _methodCodeNode.InitializeNonRelocationDependencies(_additionalDependencies);
         }
 
         private void PublishROData()
@@ -659,12 +668,12 @@ private void CompileMethodCleanup()
 
             _gcInfo = null;
             _ehClauses = null;
+            _additionalDependencies = null;
 
 #if !READYTORUN
             _debugInfo = null;
-
-            _additionalDependencies = null;
 #endif
+
             _debugLocInfos = null;
             _debugVarInfos = null;
             _lastException = null;
@@ -677,6 +686,7 @@ private void CompileMethodCleanup()
             _stashedPrecodeFixups.Clear();
             _stashedInlinedMethods.Clear();
             _ilBodiesNeeded = null;
+            _synthesizedPgoDependencies = null;
 #endif
 
             _instantiationToJitVisibleInstantiation = null;
@@ -3427,6 +3437,8 @@ private bool getTailCallHelpers(ref CORINFO_RESOLVED_TOKEN callToken, CORINFO_SI
         private byte[] _gcInfo;
         private CORINFO_EH_CLAUSE[] _ehClauses;
 
+        private DependencyList _additionalDependencies;
+
         private void allocMem(ref AllocMemArgs args)
         {
             args.hotCodeBlock = (void*)GetPin(_code = new byte[args.hotCodeSize]);
@@ -3951,11 +3963,6 @@ private uint getJitFlags(ref CORJIT_FLAGS flags, uint sizeInBytes)
             return (uint)sizeof(CORJIT_FLAGS);
         }
 
-        private PgoSchemaElem[] getPgoInstrumentationResults(MethodDesc method)
-        {
-            return _compilation.ProfileData[method]?.SchemaData;
-        }
-
         private MemoryStream _cachedMemoryStream = new MemoryStream();
 
         public static void ComputeJitPgoInstrumentationSchema(Func<object, IntPtr> objectToHandle, PgoSchemaElem[] pgoResultsSchemas, out PgoInstrumentationSchema[] nativeSchemas, MemoryStream instrumentationData, Func<TypeDesc, bool> typeFilter = null)
@@ -4033,7 +4040,19 @@ private HRESULT getPgoInstrumentationResults(CORINFO_METHOD_STRUCT_* ftnHnd, ref
 
             if (!_pgoResults.TryGetValue(methodDesc, out PgoInstrumentationResults pgoResults))
             {
-                var pgoResultsSchemas = getPgoInstrumentationResults(methodDesc);
+#if READYTORUN
+                PgoSchemaElem[] pgoResultsSchemas = _compilation.ProfileData.GetAllowSynthesis(_compilation, methodDesc, out bool isSynthesized)?.SchemaData;
+
+                if (pgoResultsSchemas != null && isSynthesized && _compilation.ProfileData.EmbedPgoDataInR2RImage)
+                {
+                    if (_synthesizedPgoDependencies == null)
+                        _synthesizedPgoDependencies = new HashSet<MethodDesc>();
+
+                    _synthesizedPgoDependencies.Add(methodDesc);
+                }
+#else
+                PgoSchemaElem[] pgoResultsSchemas = _compilation.ProfileData[methodDesc]?.SchemaData;
+#endif
                 if (pgoResultsSchemas == null)
                 {
                     pgoResults.hr = HRESULT.E_NOTIMPL;

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/InstrumentationDataTableNode.cs

@@ -2,6 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -22,13 +23,12 @@ public class InstrumentationDataTableNode : HeaderTableNode
     {
         private readonly NodeFactory _factory;
         private ReadyToRunSymbolNodeFactory _symbolNodeFactory;
-        private readonly MethodDesc[] _instrumentationDataMethods;
         private readonly ProfileDataManager _profileDataManager;
+        private readonly HashSet<MethodDesc> _methodsWithSynthesizedPgoData = new HashSet<MethodDesc>();
 
-        public InstrumentationDataTableNode(NodeFactory factory, MethodDesc[] instrumentationDataMethods, ProfileDataManager profileDataManager)
+        public InstrumentationDataTableNode(NodeFactory factory, ProfileDataManager profileDataManager)
         {
             _factory = factory;
-            _instrumentationDataMethods = instrumentationDataMethods;
             _profileDataManager = profileDataManager;
         }
 
@@ -183,12 +183,44 @@ public override void AppendMangledName(NameMangler nameMangler, Utf8StringBuilde
             sb.Append("__ReadyToRunInstrumentationDataTable");
         }
 
+        // Register some MDs that had synthesized PGO data created to be physically embedded by this node, and add
+        // the appropriate dependencies of the embedding to a dependency list.
+        public void EmbedSynthesizedPgoDataForMethods(ref DependencyList dependencies, IEnumerable<MethodDesc> mds)
+        {
+            PgoValueEmitter pgoEmitter = new PgoValueEmitter(_factory.CompilationModuleGroup, _symbolNodeFactory, false);
+            foreach (MethodDesc md in mds)
+            {
+                PgoSchemaElem[] schema = _profileDataManager[md].SchemaData;
+                Debug.Assert(schema != null);
+
+                lock (_methodsWithSynthesizedPgoData)
+                {
+                    _methodsWithSynthesizedPgoData.Add(md);
+                }
+
+                PgoProcessor.EncodePgoData(schema, pgoEmitter, false);
+            }
+
+            foreach (Import imp in pgoEmitter.ReferencedImports)
+            {
+                dependencies ??= new DependencyList();
+                dependencies.Add(imp, "Dependency of synthesized PGO data");
+            }
+        }
+
         protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFactory factory)
         {
             PgoValueEmitter pgoEmitter = new PgoValueEmitter(_factory.CompilationModuleGroup, _symbolNodeFactory, false);
-            foreach (MethodDesc method in _instrumentationDataMethods)
+            foreach (EcmaModule inputModule in _factory.CompilationModuleGroup.CompilationModuleSet)
             {
-                PgoProcessor.EncodePgoData(_profileDataManager[method].SchemaData, pgoEmitter, false);
+                foreach (MethodDesc method in _profileDataManager.GetInputProfileDataMethodsForModule(inputModule))
+                {
+                    PgoSchemaElem[] schema = _profileDataManager[method].SchemaData;
+                    if (schema != null)
+                    {
+                        PgoProcessor.EncodePgoData(schema, pgoEmitter, false);
+                    }
+                }
             }
             DependencyListEntry[] symbols = new DependencyListEntry[pgoEmitter.ReferencedImports.Count];
             for (int i = 0; i < symbols.Length; i++)
@@ -199,7 +231,6 @@ protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFact
             return new DependencyList(symbols);
         }
 
-
         public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
         {
             if (relocsOnly)
@@ -216,7 +247,25 @@ public override ObjectData GetData(NodeFactory factory, bool relocsOnly = false)
 
             Dictionary<byte[], BlobVertex> uniqueInstrumentationData = new Dictionary<byte[], BlobVertex>(ByteArrayComparer.Instance);
 
-            foreach (MethodDesc method in _instrumentationDataMethods)
+            HashSet<MethodDesc> methodsToInsert = new();
+            foreach (EcmaModule inputModule in _factory.CompilationModuleGroup.CompilationModuleSet)
+            {
+                foreach (MethodDesc method in _profileDataManager.GetInputProfileDataMethodsForModule(inputModule))
+                {
+                    PgoSchemaElem[] schema = _profileDataManager[method].SchemaData;
+                    if (schema != null)
+                    {
+                        methodsToInsert.Add(method);
+                    }
+                }
+            }
+
+            methodsToInsert.UnionWith(_methodsWithSynthesizedPgoData);
+
+            MethodDesc[] methods = methodsToInsert.ToArray();
+            methods.MergeSort(TypeSystemComparer.Instance.Compare);
+
+            foreach (MethodDesc method in methods)
             {
                 pgoEmitter.Clear();
                 PgoProcessor.EncodePgoData(CorInfoImpl.ConvertTypeHandleHistogramsToCompactTypeHistogramFormat(_profileDataManager[method].SchemaData, factory.CompilationModuleGroup), pgoEmitter, false);

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRun/MethodWithGCInfo.cs

@@ -6,6 +6,7 @@
 using System.Diagnostics;
 using System.Linq;
 using Internal.JitInterface;
+using Internal.Pgo;
 using Internal.Text;
 using Internal.TypeSystem;
 using Internal.TypeSystem.Ecma;
@@ -29,6 +30,7 @@ public class MethodWithGCInfo : ObjectNode, IMethodBodyNode, ISymbolDefinitionNo
         private List<ISymbolNode> _fixups;
         private MethodDesc[] _inlinedMethods;
         private bool _lateTriggeredCompilation;
+        private DependencyList _nonRelocationDependencies;
 
         public MethodWithGCInfo(MethodDesc methodDesc)
         {
@@ -272,6 +274,11 @@ protected override DependencyList ComputeNonRelocationBasedDependencies(NodeFact
                 dependencyList.Add(node, "classMustBeLoadedBeforeCodeIsRun");
             }
 
+            if (_nonRelocationDependencies != null)
+            {
+                dependencyList.AddRange(_nonRelocationDependencies);
+            }
+
             return dependencyList;
         }
 
@@ -382,6 +389,11 @@ public void InitializeInliningInfo(MethodDesc[] inlinedMethods, NodeFactory fact
                 RegisterInlineeModuleIndices(factory);
         }
 
+        public void InitializeNonRelocationDependencies(DependencyList dependencies)
+        {
+            _nonRelocationDependencies = dependencies;
+        }
+
         public int Offset => 0;
         public override bool IsShareable => throw new NotImplementedException();
         public override bool ShouldSkipEmittingObjectNode(NodeFactory factory) => IsEmpty;

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/DependencyAnalysis/ReadyToRunCodegenNodeFactory.cs

@@ -779,22 +779,26 @@ public void AttachToDependencyGraph(DependencyAnalyzerBase<NodeFactory> graph, I
             if ((ProfileDataManager != null) && (ProfileDataManager.EmbedPgoDataInR2RImage))
             {
                 // Profile instrumentation data attaches here
-                HashSet<MethodDesc> methodsToInsertInstrumentationDataFor = new HashSet<MethodDesc>();
-                foreach (EcmaModule inputModule in CompilationModuleGroup.CompilationModuleSet)
+
+                bool HasAnyProfileDataForInput()
                 {
-                    foreach (MethodDesc method in ProfileDataManager.GetMethodsForModuleDesc(inputModule))
+                    foreach (EcmaModule inputModule in CompilationModuleGroup.CompilationModuleSet)
                     {
-                        if (ProfileDataManager[method].SchemaData != null)
+                        foreach (MethodDesc method in ProfileDataManager.GetInputProfileDataMethodsForModule(inputModule))
                         {
-                            methodsToInsertInstrumentationDataFor.Add(method);
+                            if (ProfileDataManager[method].SchemaData != null)
+                            {
+                                return true;
+                            }
                         }
                     }
+
+                    return false;
                 }
-                if (methodsToInsertInstrumentationDataFor.Count != 0)
+
+                if (ProfileDataManager.SynthesizeRandomPgoData || HasAnyProfileDataForInput())
                 {
-                    MethodDesc[] methodsToInsert = methodsToInsertInstrumentationDataFor.ToArray();
-                    methodsToInsert.MergeSort(TypeSystemComparer.Instance.Compare);
-                    InstrumentationDataTable = new InstrumentationDataTableNode(this, methodsToInsert, ProfileDataManager);
+                    InstrumentationDataTable = new InstrumentationDataTableNode(this, ProfileDataManager);
                     Header.Add(Internal.Runtime.ReadyToRunSectionType.PgoInstrumentationData, InstrumentationDataTable, InstrumentationDataTable);
                 }
             }

src/coreclr/tools/aot/ILCompiler.ReadyToRun/Compiler/ProfileData.cs

@@ -62,11 +62,8 @@ public abstract class ProfileData
         public abstract IEnumerable<MethodProfileData> GetAllMethodProfileData();
         public abstract byte[] GetMethodBlockCount(MethodDesc m);
 
-        public static void MergeProfileData(ref bool partialNgen, Dictionary<MethodDesc, MethodProfileData> mergedProfileData, ProfileData profileData)
+        public static void MergeProfileData(Dictionary<MethodDesc, MethodProfileData> mergedProfileData, ProfileData profileData)
         {
-            if (profileData.PartialNGen)
-                partialNgen = true;
-
             PgoSchemaElem[][] schemaElemMergerArray = new PgoSchemaElem[2][];
 
             foreach (MethodProfileData data in profileData.GetAllMethodProfileData())