[msbuild] Sort inputs when doing aot compilation and native compilation. (#22755)

Sort inputs when doing AOT compilation and native code compilation, so that we
start by processing the input that takes the longest to process. This helps
maximizing usage of parallel resources, because there's a smaller chance we'll
be left at the end working on a single long-running task.

Some tentative timings from compiling monotouch-test locally, it shows a few
seconds improvement (which percentage-wise can be significant).

| Task                    | Before | After |
| ----------------------- | ------ | ----- |
| Native code compilation | ~25s   |  ~22s |
| AOT compilation         | ~23s   |  ~22s |

Author: rolfbjarne

msbuild/Xamarin.MacDev.Tasks/Tasks/AOTCompile.cs

@@ -272,6 +272,25 @@ public override bool Execute ()
 			if (dedupAssembly is not null && !assembliesToAOT.Contains (dedupAssembly))
 				assembliesToAOT.Add (dedupAssembly);
 
+			// Sort the assemblies:
+			// We want to start with the assemblies that takes the longest to compile, because
+			// that will make most efficient use of parallel resources.
+			// 1. The dedup assembly is typically quite big, so do that first.
+			// 2. Sort the rest of the assemblies by size, in decreasing order.
+			var sortedAssembliesToAOT = assembliesToAOT
+				// Compute the data we need to sort. We set file length to long.MaxValue if it's a dedup assembly so that it sorts where we want it
+				.Select (item => {
+					var isDedup = Boolean.TryParse (item.GetMetadata ("IsDedupAssembly"), out var isDedupAssembly) && isDedupAssembly;
+					return (Item: item, InputLength: isDedup ? long.MaxValue : new FileInfo (item.GetMetadata ("Input")).Length);
+				})
+				// Sort
+				.OrderByDescending (x => x.InputLength);
+			foreach (var item in sortedAssembliesToAOT) {
+				Log.LogMessage (MessageImportance.Low, $"Ahead-of-time compiling with sort order {item.InputLength}: {item.Item.GetMetadata ("Input")}");
+			}
+
+			assembliesToAOT = sortedAssembliesToAOT.Select (v => v.Item).ToList ();
+
 			Directory.CreateDirectory (OutputDirectory);
 
 			var aotAssemblyFiles = new List<ITaskItem> ();
@@ -290,6 +309,7 @@ public override bool Execute ()
 				var aotAssemblyItem = new TaskItem (aotAssembly);
 				aotAssemblyItem.SetMetadata ("Arguments", "-Xlinker -rpath -Xlinker @executable_path/ -Qunused-arguments -x assembler -D DEBUG");
 				aotAssemblyItem.SetMetadata ("Arch", arch);
+				aotAssemblyItem.SetMetadata ("IsDedupAssembly", asm.GetMetadata ("IsDedupAssembly"));
 				aotAssemblyFiles.Add (aotAssemblyItem);
 
 				var arguments = new List<string> ();

msbuild/Xamarin.MacDev.Tasks/Tasks/CompileNativeCode.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 
 using Microsoft.Build.Framework;
@@ -48,10 +49,29 @@ public override bool Execute ()
 				return new TaskRunner (SessionId, BuildEngine4).RunAsync (this).Result;
 			}
 
-			var processes = new Task<Execution> [CompileInfo.Length];
+			// Sort the list of inputs to compile:
+			// We want to start with the input that takes the longest to compile, because
+			// that will make most efficient use of parallel resources.
+			// 1. The dedup assembly is typically quite big, so do that first.
+			// 2. Sort the rest of the inputs by size, in decreasing order.
+			var sortedCompileInfo = CompileInfo
+				// Compute the data we need to sort. We set file length to long.MaxValue if it's a dedup assembly so that it sorts where we want it
+				.Select (item => {
+					var isDedup = Boolean.TryParse (item.GetMetadata ("IsDedupAssembly"), out var isDedupAssembly) && isDedupAssembly;
+					return (Item: item, InputLength: isDedup ? long.MaxValue : new FileInfo (item.ItemSpec).Length);
+				})
+				// Sort
+				.OrderByDescending (x => x.InputLength);
+			foreach (var item in sortedCompileInfo) {
+				Log.LogMessage (MessageImportance.Low, $"Compiling with sort order {item.InputLength}: {item.Item.ItemSpec}");
+			}
+
+			var compileInfo = sortedCompileInfo.Select (v => v.Item).ToArray ();
+
+			var processes = new Task<Execution> [compileInfo.Length];
 
-			for (var i = 0; i < CompileInfo.Length; i++) {
-				var info = CompileInfo [i];
+			for (var i = 0; i < compileInfo.Length; i++) {
+				var info = compileInfo [i];
 				var src = Path.GetFullPath (info.ItemSpec);
 				var arguments = new List<string> ();