Refactor to allow fast-path

src/tasks/AotCompilerTask/MonoAOTCompiler.cs

@@ -357,6 +357,10 @@ private bool ExecuteInternal()
 
         _cache = new FileCache(CacheFilePath, Log);
 
+        List<PrecompileArguments> argsList = new();
+        foreach (var assemblyItem in _assembliesToCompile)
+            argsList.Add(GetPrecompileArgumentsFor(assemblyItem, monoPaths));
+
         //FIXME: check the nothing changed at all case
 
         _totalNumAssemblies = _assembliesToCompile.Count;
@@ -366,18 +370,18 @@ private bool ExecuteInternal()
 
         if (DisableParallelAot || allowedParallelism == 1)
         {
-            foreach (var assemblyItem in _assembliesToCompile)
+            foreach (var args in argsList)
             {
-                if (!PrecompileLibrarySerial(assemblyItem, monoPaths))
+                if (!PrecompileLibrarySerial(args))
                     return !Log.HasLoggedErrors;
             }
         }
         else
         {
             ParallelLoopResult result = Parallel.ForEach(
-                                                    _assembliesToCompile,
+                                                    argsList,
                                                     new ParallelOptions { MaxDegreeOfParallelism = allowedParallelism },
-                                                    (assemblyItem, state) => PrecompileLibraryParallel(assemblyItem, monoPaths, state));
+                                                    (args, state) => PrecompileLibraryParallel(args, state));
 
             if (!result.IsCompleted)
             {
@@ -454,7 +458,7 @@ static bool ShouldSkip(ITaskItem asmItem)
             => bool.TryParse(asmItem.GetMetadata("AOT_InternalForceToInterpret"), out bool skip) && skip;
     }
 
-    private bool PrecompileLibrary(ITaskItem assemblyItem, string? monoPaths)
+    private PrecompileArguments GetPrecompileArgumentsFor(ITaskItem assemblyItem, string? monoPaths)
     {
         string assembly = assemblyItem.GetMetadata("FullPath");
         string assemblyDir = Path.GetDirectoryName(assembly)!;
@@ -463,7 +467,6 @@ private bool PrecompileLibrary(ITaskItem assemblyItem, string? monoPaths)
         var processArgs = new List<string>();
         bool isDedup = assembly == DedupAssembly;
         List<ProxyFile> proxyFiles = new(capacity: 5);
-        string msgPrefix = $"[{Path.GetFileName(assembly)}] ";
 
         var a = assemblyItem.GetMetadata("AotArguments");
         if (a != null)
@@ -674,16 +677,26 @@ private bool PrecompileLibrary(ITaskItem assemblyItem, string? monoPaths)
             sw.WriteLine(responseFileContent);
         }
 
-        string workingDir = assemblyDir;
+        return new PrecompileArguments(ResponseFilePath: responseFilePath,
+                                        EnvironmentVariables: envVariables,
+                                        WorkingDir: assemblyDir,
+                                        AOTAssembly: aotAssembly,
+                                        ProxyFiles: proxyFiles);
+    }
 
+    private bool PrecompileLibrary(PrecompileArguments args)
+    {
+        string assembly = args.AOTAssembly.GetMetadata("FullPath");
         try
         {
+            string msgPrefix = $"[{Path.GetFileName(assembly)}] ";
+
             // run the AOT compiler
             (int exitCode, string output) = Utils.TryRunProcess(Log,
                                                                 CompilerBinaryPath,
-                                                                $"--response=\"{responseFilePath}\"",
-                                                                envVariables,
-                                                                workingDir,
+                                                                $"--response=\"{args.ResponseFilePath}\"",
+                                                                args.EnvironmentVariables,
+                                                                args.WorkingDir,
                                                                 silent: true,
                                                                 debugMessageImportance: MessageImportance.Low,
                                                                 label: Path.GetFileName(assembly));
@@ -692,9 +705,9 @@ private bool PrecompileLibrary(ITaskItem assemblyItem, string? monoPaths)
             // Log the command in a compact format which can be copy pasted
             {
                 StringBuilder envStr = new StringBuilder(string.Empty);
-                foreach (KeyValuePair<string, string> kvp in envVariables)
+                foreach (KeyValuePair<string, string> kvp in args.EnvironmentVariables)
                     envStr.Append($"{kvp.Key}={kvp.Value} ");
-                Log.LogMessage(importance, $"{msgPrefix}Exec (with response file contents expanded) in {workingDir}: {envStr}{CompilerBinaryPath} {responseFileContent}");
+                Log.LogMessage(importance, $"{msgPrefix}Exec (with response file contents expanded) in {args.WorkingDir}: {envStr}{CompilerBinaryPath} {File.ReadAllText(args.ResponseFilePath)}");
             }
 
             Log.LogMessage(importance, output);
@@ -713,66 +726,66 @@ private bool PrecompileLibrary(ITaskItem assemblyItem, string? monoPaths)
         }
         finally
         {
-            File.Delete(responseFilePath);
+            File.Delete(args.ResponseFilePath);
         }
 
         bool copied = false;
-        foreach (var proxyFile in proxyFiles)
+        foreach (var proxyFile in args.ProxyFiles)
         {
             copied |= proxyFile.CopyOutputFileIfChanged();
             _fileWrites.Add(proxyFile.TargetFile);
         }
 
         if (copied)
         {
-            string copiedFiles = string.Join(", ", proxyFiles.Select(tf => Path.GetFileName(tf.TargetFile)));
+            string copiedFiles = string.Join(", ", args.ProxyFiles.Select(tf => Path.GetFileName(tf.TargetFile)));
             int count = Interlocked.Increment(ref _numCompiled);
             Log.LogMessage(MessageImportance.High, $"[{count}/{_totalNumAssemblies}] {Path.GetFileName(assembly)} -> {copiedFiles}");
         }
 
-        compiledAssemblies.GetOrAdd(aotAssembly.ItemSpec, aotAssembly);
+        compiledAssemblies.GetOrAdd(args.AOTAssembly.ItemSpec, args.AOTAssembly);
         return true;
     }
 
-    private bool PrecompileLibrarySerial(ITaskItem assemblyItem, string? monoPaths)
+    private bool PrecompileLibrarySerial(PrecompileArguments args)
     {
         try
         {
-            if (PrecompileLibrary(assemblyItem, monoPaths))
+            if (PrecompileLibrary(args))
                 return true;
         }
         catch (LogAsErrorException laee)
         {
-            Log.LogError($"Precompile failed for {assemblyItem}: {laee.Message}");
+            Log.LogError($"Precompile failed for {args.AOTAssembly}: {laee.Message}");
         }
         catch (Exception ex)
         {
             if (Log.HasLoggedErrors)
-                Log.LogMessage(MessageImportance.Low, $"Precompile failed for {assemblyItem}: {ex}");
+                Log.LogMessage(MessageImportance.Low, $"Precompile failed for {args.AOTAssembly}: {ex}");
             else
-                Log.LogError($"Precompile failed for {assemblyItem}: {ex}");
+                Log.LogError($"Precompile failed for {args.AOTAssembly}: {ex}");
         }
 
         return false;
     }
 
-    private void PrecompileLibraryParallel(ITaskItem assemblyItem, string? monoPaths, ParallelLoopState state)
+    private void PrecompileLibraryParallel(PrecompileArguments args, ParallelLoopState state)
     {
         try
         {
-            if (PrecompileLibrary(assemblyItem, monoPaths))
+            if (PrecompileLibrary(args))
                 return;
         }
         catch (LogAsErrorException laee)
         {
-            Log.LogError($"Precompile failed for {assemblyItem}: {laee.Message}");
+            Log.LogError($"Precompile failed for {args.AOTAssembly}: {laee.Message}");
         }
         catch (Exception ex)
         {
             if (Log.HasLoggedErrors)
-                Log.LogMessage(MessageImportance.Low, $"Precompile failed for {assemblyItem}: {ex}");
+                Log.LogMessage(MessageImportance.Low, $"Precompile failed for {args.AOTAssembly}: {ex}");
             else
-                Log.LogError($"Precompile failed for {assemblyItem}: {ex}");
+                Log.LogError($"Precompile failed for {args.AOTAssembly}: {ex}");
         }
 
         state.Break();
@@ -908,6 +921,24 @@ private static IList<ITaskItem> ConvertAssembliesDictToOrderedList(ConcurrentDic
         }
         return outItems;
     }
+
+    internal class PrecompileArguments
+    {
+        public PrecompileArguments(string ResponseFilePath, IDictionary<string, string> EnvironmentVariables, string WorkingDir, ITaskItem AOTAssembly, IList<ProxyFile> ProxyFiles)
+        {
+            this.ResponseFilePath  = ResponseFilePath;
+            this.EnvironmentVariables  = EnvironmentVariables;
+            this.WorkingDir  = WorkingDir;
+            this.AOTAssembly  = AOTAssembly;
+            this.ProxyFiles  = ProxyFiles;
+        }
+
+        public string                       ResponseFilePath     { get; private set; }
+        public IDictionary<string, string>  EnvironmentVariables { get; private set; }
+        public string                       WorkingDir           { get; private set; }
+        public ITaskItem                    AOTAssembly          { get; private set; }
+        public IList<ProxyFile>             ProxyFiles           { get; private set; }
+    }
 }
 
 internal class FileCache
@@ -1017,6 +1048,7 @@ public bool CopyOutputFileIfChanged()
             File.Delete(TempFile);
         }
     }
+
 }
 
 public enum MonoAotMode