[JavaCallableWrappers] Parallel.ForEach per assembly

src/Java.Interop.Tools.Cecil/Java.Interop.Tools.Cecil/DirectoryAssemblyResolver.cs

@@ -29,7 +29,7 @@
 
 using System;
 using System.Diagnostics;
-using System.Collections;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -61,7 +61,7 @@ public class DirectoryAssemblyResolver : IAssemblyResolver {
 
 		public ICollection<string> SearchDirectories {get; private set;}
 
-		Dictionary<string, AssemblyDefinition> cache;
+		ConcurrentDictionary<string, AssemblyDefinition> cache;
 		bool loadDebugSymbols;
 		Action<TraceLevel, string>              logger;
 
@@ -82,7 +82,7 @@ public DirectoryAssemblyResolver (Action<TraceLevel, string> logger, bool loadDe
 		{
 			if (logger == null)
 				throw new ArgumentNullException (nameof (logger));
-			cache = new Dictionary<string, AssemblyDefinition> ();
+			cache = new ConcurrentDictionary<string, AssemblyDefinition> ();
 			this.loadDebugSymbols = loadDebugSymbols;
 			this.logger       = logger;
 			SearchDirectories = new List<string> ();

src/Java.Interop.Tools.JavaCallableWrappers/Java.Interop.Tools.JavaCallableWrappers/JavaTypeScanner.cs

@@ -1,12 +1,12 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
-using System.Text;
+using System.Threading.Tasks;
 using Mono.Cecil;
 
 using Java.Interop.Tools.Cecil;
-using Java.Interop.Tools.Diagnostics;
 using Java.Interop.Tools.TypeNameMappings;
 
 namespace Java.Interop.Tools.JavaCallableWrappers
@@ -29,23 +29,38 @@ public List<TypeDefinition> GetJavaTypes (IEnumerable<string> assemblies, IAssem
 
 			foreach (var assembly in assemblies) {
 				var assm = resolver.GetAssembly (assembly);
-
 				foreach (ModuleDefinition md in assm.Modules) {
 					foreach (TypeDefinition td in md.Types) {
-						AddJavaTypes (javaTypes, td);
+						AddJavaTypes (javaTypes.Add, td);
 					}
 				}
 			}
 
 			return javaTypes;
 		}
 
-		void AddJavaTypes (List<TypeDefinition> javaTypes, TypeDefinition type)
+		public List<TypeDefinition> GetJavaTypesInParallel (IEnumerable<string> assemblies, IAssemblyResolver resolver)
+		{
+			var javaTypes = new BlockingCollection<TypeDefinition> ();
+
+			Parallel.ForEach (assemblies, assembly => {
+				var assm = resolver.GetAssembly (assembly);
+				foreach (ModuleDefinition md in assm.Modules) {
+					foreach (TypeDefinition td in md.Types) {
+						AddJavaTypes (javaTypes.Add, td);
+					}
+				}
+			});
+
+			return javaTypes.ToList ();
+		}
+
+		void AddJavaTypes (Action<TypeDefinition> addMethod, TypeDefinition type)
 		{
 			if (type.IsSubclassOf ("Java.Lang.Object") || type.IsSubclassOf ("Java.Lang.Throwable")) {
 
 				// For subclasses of e.g. Android.App.Activity.
-				javaTypes.Add (type);
+				addMethod (type);
 			} else if (type.IsClass && !type.IsSubclassOf ("System.Exception") && type.ImplementsInterface ("Android.Runtime.IJavaObject")) {
 				var level   = ErrorOnCustomJavaObject ? TraceLevel.Error : TraceLevel.Warning;
 				var prefix  = ErrorOnCustomJavaObject ? "error" : "warning";
@@ -59,7 +74,7 @@ void AddJavaTypes (List<TypeDefinition> javaTypes, TypeDefinition type)
 				return;
 
 			foreach (TypeDefinition nested in type.NestedTypes)
-				AddJavaTypes (javaTypes, nested);
+				AddJavaTypes (addMethod, nested);
 		}
 
 		public static bool ShouldSkipJavaCallableWrapperGeneration (TypeDefinition type)

src/Java.Interop.Tools.JavaCallableWrappers/Test/Java.Interop.Tools.JavaCallableWrappers-Tests.csproj

@@ -34,6 +34,8 @@
       <HintPath>..\..\..\packages\NUnit.3.7.1\lib\net45\nunit.framework.dll</HintPath>
     </Reference>
     <Reference Include="System" />
+    <Reference Include="System.IO.Compression" />
+    <Reference Include="System.IO.Compression.FileSystem" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Java.Interop.Tools.JavaCallableWrappers\JavaCallableWrapperGeneratorTests.cs" />
@@ -47,6 +49,9 @@
     <Compile Include="Android.Content\ContentProviderAttribute.cs" />
   </ItemGroup>
   <ItemGroup>
+    <Content Include="Data\Assemblies.zip">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <None Include="packages.config" />
   </ItemGroup>
   <ItemGroup>

src/Java.Interop.Tools.JavaCallableWrappers/Test/Java.Interop.Tools.JavaCallableWrappers/JavaCallableWrapperGeneratorTests.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
+using System.IO.Compression;
 using System.Linq;
 using System.Threading.Tasks;
 
@@ -13,6 +16,7 @@
 using Java.Interop.Tools.TypeNameMappings;
 
 using Xamarin.Android.ToolsTests;
+using Java.Interop.Tools.Cecil;
 
 namespace Java.Interop.Tools.JavaCallableWrappersTests
 {
@@ -491,6 +495,66 @@ public void monodroidClearReferences ()
 ";
 			Assert.AreEqual (expected, actual);
 		}
+
+		[Test, Repeat (10)]
+		public void GenerateInParallel ()
+		{
+			var zipPath = Path.Combine (Path.GetDirectoryName (GetType ().Assembly.Location), "Data", "assemblies.zip");
+			var dest = Path.Combine (Path.GetTempPath (), Path.GetRandomFileName ());
+			try {
+				Directory.CreateDirectory (dest);
+				var assemblies = new List<string> ();
+
+				using (var zip = ZipFile.OpenRead (zipPath)) {
+					foreach (var entry in zip.Entries) {
+						var path = Path.Combine (dest, entry.FullName);
+						assemblies.Add (path);
+
+						using (var fs = File.Create (path))
+						using (var zs = entry.Open ()) {
+							zs.CopyTo (fs);
+						}
+					}
+				}
+
+				Action<TraceLevel, string> logger = (l, m) => {
+					TestContext.WriteLine ($"{l} {m}");
+				};
+
+				using (var res = new DirectoryAssemblyResolver (logger, loadDebugSymbols: false)) {
+					res.SearchDirectories.Add (dest);
+					foreach (var assembly in assemblies) {
+						res.Load (assembly);
+					}
+
+					var scanner = new JavaTypeScanner (logger);
+					var sw = new Stopwatch ();
+
+					sw.Reset ();
+					sw.Start ();
+					var parallelTypes = scanner.GetJavaTypesInParallel (assemblies, res);
+					sw.Stop ();
+					TestContext.WriteLine ($"Parallel took: {sw.Elapsed}");
+
+					sw.Reset ();
+					sw.Start ();
+					var types = scanner.GetJavaTypes (assemblies, res);
+					sw.Stop ();
+					TestContext.WriteLine ($"Non parallel took: {sw.Elapsed}");
+
+					types.Sort ((a, b) => a.FullName.CompareTo (b.FullName));
+					parallelTypes.Sort ((a, b) => a.FullName.CompareTo (b.FullName));
+
+					Assert.AreEqual (types.Count, parallelTypes.Count);
+					for (int i = 0; i < types.Count; i++) {
+						Assert.AreEqual (types [i].FullName, parallelTypes [i].FullName);
+					}
+				}
+
+			} finally {
+				Directory.Delete (dest, true);
+			}
+		}
 	}
 }