Make prior parallelism work configurable (enabled by default)

Co-Authored-By: Justin <[email protected]>

Author: Col-E

recaf-core/src/main/java/software/coley/recaf/services/transform/TransformationApplier.java

@@ -44,6 +44,7 @@
 public class TransformationApplier {
 	private static final DebuggingLogger logger = Logging.get(TransformationApplier.class);
 	private final TransformationManager transformationManager;
+	private final TransformationApplierConfig transformApplyConfig;
 	private final InheritanceGraph inheritanceGraph;
 	private final MappingApplier mappingApplier;
 	private final Workspace workspace;
@@ -52,6 +53,8 @@ public class TransformationApplier {
 	/**
 	 * @param transformationManager
 	 * 		Manager to pull transformer instances from.
+	 * @param transformApplyConfig
+	 * 		Transformation applier config.
 	 * @param inheritanceGraph
 	 * 		Inheritance graph to use for frame computation <i>(Some transformers will trigger this)</i>.
 	 * @param mappingApplier
@@ -60,10 +63,12 @@ public class TransformationApplier {
 	 * 		Workspace with classes to transform.
 	 */
 	public TransformationApplier(@Nonnull TransformationManager transformationManager,
+	                             @Nonnull TransformationApplierConfig transformApplyConfig,
 	                             @Nonnull InheritanceGraph inheritanceGraph,
 	                             @Nonnull MappingApplier mappingApplier,
 	                             @Nonnull Workspace workspace) {
 		this.transformationManager = transformationManager;
+		this.transformApplyConfig = transformApplyConfig;
 		this.inheritanceGraph = inheritanceGraph;
 		this.mappingApplier = mappingApplier;
 		this.workspace = workspace;
@@ -141,7 +146,9 @@ public JvmTransformResult transformJvm(@Nonnull List<Class<? extends JvmClassTra
 		}
 		AtomicInteger finalPass = new AtomicInteger();
 		List<JvmClassTransformer> prunedTransformers = new ArrayList<>();
-		try (ExecutorService service = ThreadPoolFactory.newFixedThreadPool("transform-apply")) {
+		try (ExecutorService service = transformApplyConfig.doParallelize().getValue() ?
+				ThreadPoolFactory.newFixedThreadPool("transform-apply") :
+				ThreadPoolFactory.newSingleThreadExecutor("transform-apply")) {
 			resource.jvmAllClassBundleStreamRecursive().forEach(bundle -> {
 				List<Callable<Void>> tasks = new ArrayList<>(bundle.size());
 				BundlePathNode bundlePathNode = resourcePath.child(bundle);

recaf-core/src/main/java/software/coley/recaf/services/transform/TransformationApplierConfig.java

@@ -1,8 +1,11 @@
 package software.coley.recaf.services.transform;
 
+import jakarta.annotation.Nonnull;
 import jakarta.enterprise.context.ApplicationScoped;
 import jakarta.inject.Inject;
+import software.coley.observables.ObservableBoolean;
 import software.coley.recaf.config.BasicConfigContainer;
+import software.coley.recaf.config.BasicConfigValue;
 import software.coley.recaf.config.ConfigGroups;
 import software.coley.recaf.services.ServiceConfig;
 
@@ -13,8 +16,19 @@
  */
 @ApplicationScoped
 public class TransformationApplierConfig extends BasicConfigContainer implements ServiceConfig {
+	private final ObservableBoolean parallelize = new ObservableBoolean(true);
+
 	@Inject
 	public TransformationApplierConfig() {
 		super(ConfigGroups.SERVICE_TRANSFORM, TransformationApplierService.SERVICE_ID + CONFIG_SUFFIX);
+		addValue(new BasicConfigValue<>("parallelize", boolean.class, parallelize));
+	}
+
+	/**
+	 * @return {@code true} to enable parallelization of transformer applications.
+	 */
+	@Nonnull
+	public ObservableBoolean doParallelize() {
+		return parallelize;
 	}
 }

recaf-core/src/main/java/software/coley/recaf/services/transform/TransformationApplierService.java

@@ -32,18 +32,21 @@ public class TransformationApplierService implements Service {
 	private final MappingApplierService mappingService;
 	private final WorkspaceManager workspaceManager;
 	private final TransformationApplierConfig config;
+	private final TransformationApplierConfig applierConfig;
 
 	@Inject
 	public TransformationApplierService(@Nonnull TransformationManager transformationManager,
 	                                    @Nonnull InheritanceGraphService graphService,
-										@Nonnull MappingApplierService mappingService,
+	                                    @Nonnull MappingApplierService mappingService,
 	                                    @Nonnull WorkspaceManager workspaceManager,
-	                                    @Nonnull TransformationApplierConfig config) {
+	                                    @Nonnull TransformationApplierConfig config,
+	                                    @Nonnull TransformationApplierConfig applierConfig) {
 		this.graphService = graphService;
 		this.mappingService = mappingService;
 		this.workspaceManager = workspaceManager;
 		this.transformationManager = transformationManager;
 		this.config = config;
+		this.applierConfig = applierConfig;
 	}
 
 	/**
@@ -94,7 +97,7 @@ public TransformationApplier newApplierForCurrentWorkspace() {
 	@Nonnull
 	private TransformationApplier newApplier(@Nonnull Workspace workspace, @Nonnull InheritanceGraph inheritanceGraph,
 	                                         @Nonnull MappingApplier mappingApplier) {
-		return new TransformationApplier(transformationManager, inheritanceGraph, mappingApplier, workspace);
+		return new TransformationApplier(transformationManager, applierConfig, inheritanceGraph, mappingApplier, workspace);
 	}
 
 	@Nonnull

recaf-core/src/main/java/software/coley/recaf/services/workspace/io/BasicResourceImporter.java

@@ -210,7 +210,9 @@ private WorkspaceFileResource handleZip(@Nonnull WorkspaceFileResourceBuilder bu
 
 		// Build model from the contained files in the ZIP
 		int maxZipDepth = config.getMaxEmbeddedZipDepth().getValue();
-		try (ExecutorService service = ThreadPoolFactory.newFixedThreadPool("zip-import")) {
+		try (ExecutorService service = config.doParallelize().getValue() ?
+				ThreadPoolFactory.newFixedThreadPool("zip-import") :
+				ThreadPoolFactory.newSingleThreadExecutor("zip-import")) {
 			List<Callable<Void>> tasks = new ArrayList<>();
 			for (LocalFileHeader header : archive.getLocalFiles()) {
 				tasks.add(() -> {
@@ -294,7 +296,9 @@ private WorkspaceDirectoryResource handleDirectory(@Nonnull WorkspaceResourceBui
 		Map<String, WorkspaceFileResource> embeddedResources = new ConcurrentHashMap<>();
 
 		// Walk the directory
-		try (ExecutorService service = ThreadPoolFactory.newFixedThreadPool("directory-import")) {
+		try (ExecutorService service = config.doParallelize().getValue() ?
+				ThreadPoolFactory.newFixedThreadPool("directory-import") :
+				ThreadPoolFactory.newSingleThreadExecutor("directory-import")) {
 			List<Callable<Void>> tasks = new ArrayList<>();
 			Files.walkFileTree(directoryPath, new SimpleFileVisitor<>() {
 				@Override

recaf-core/src/main/java/software/coley/recaf/services/workspace/io/ResourceImporterConfig.java

@@ -42,6 +42,7 @@ public class ResourceImporterConfig extends BasicConfigContainer implements Serv
 	private final ObservableBoolean ignoreFileLengths = new ObservableBoolean(false);
 	private final ObservableBoolean adoptStandardCenFileNames = new ObservableBoolean(false);
 	private final ObservableInteger maxEmbeddedZipDepth = new ObservableInteger(3);
+	private final ObservableBoolean parallelize = new ObservableBoolean(true);
 
 	@Inject
 	public ResourceImporterConfig() {
@@ -53,6 +54,7 @@ public ResourceImporterConfig() {
 		addValue(new BasicConfigValue<>("ignore-file-lengths", boolean.class, ignoreFileLengths));
 		addValue(new BasicConfigValue<>("adapt-standard-cen-file-names", boolean.class, adoptStandardCenFileNames));
 		addValue(new BasicConfigValue<>("max-embedded-zip-depth", int.class, maxEmbeddedZipDepth));
+		addValue(new BasicConfigValue<>("parallelize", boolean.class, parallelize));
 	}
 
 	/**
@@ -121,6 +123,14 @@ public ObservableInteger getMaxEmbeddedZipDepth() {
 		return maxEmbeddedZipDepth;
 	}
 
+	/**
+	 * @return {@code true} to enable parallelization of import logic.
+	 */
+	@Nonnull
+	public ObservableBoolean doParallelize() {
+		return parallelize;
+	}
+
 	/**
 	 * @return Mapping of input bytes to a ZIP archive model.
 	 */

recaf-core/src/test/java/software/coley/recaf/services/transform/TransformationApplierTest.java

@@ -59,7 +59,7 @@ void independentAB() {
 
 		// If we transform with "B" we should observe that only "B" is called on sine the two hold no relation
 		TransformationManager manager = new TransformationManager(map);
-		TransformationApplier applier = new TransformationApplier(manager, inheritanceGraph, mappingApplier, workspace);
+		TransformationApplier applier = new TransformationApplier(manager, config, inheritanceGraph, mappingApplier, workspace);
 		assertDoesNotThrow(() -> applier.transformJvm(Collections.singletonList(JvmTransformerB.class)));
 
 		// "A" not used
@@ -83,7 +83,7 @@ void dependentAB() {
 
 		// If we transform with "B" we should observe that both "B" and "A" were called on.
 		TransformationManager manager = new TransformationManager(map);
-		TransformationApplier applier = new TransformationApplier(manager, inheritanceGraph, mappingApplier, workspace);
+		TransformationApplier applier = new TransformationApplier(manager, config, inheritanceGraph, mappingApplier, workspace);
 		assertDoesNotThrow(() -> applier.transformJvm(Collections.singletonList(JvmTransformerDependingOnA.class)));
 		verify(transformerA, times(1)).transform(any(), same(workspace), any(), any(), any());
 		verify(transformerB, times(1)).transform(any(), same(workspace), any(), any(), any());
@@ -103,7 +103,7 @@ void cycleAB() {
 
 		// If we transform with "A" or "B" we should observe an exception due to the detected cycle
 		TransformationManager manager = new TransformationManager(map);
-		TransformationApplier applier = new TransformationApplier(manager, inheritanceGraph, mappingApplier, workspace);
+		TransformationApplier applier = new TransformationApplier(manager, config, inheritanceGraph, mappingApplier, workspace);
 		assertThrows(TransformationException.class, () -> applier.transformJvm(Collections.singletonList(JvmCycleA.class)));
 		assertThrows(TransformationException.class, () -> applier.transformJvm(Collections.singletonList(JvmCycleB.class)));
 		verify(transformerA, never()).transform(any(), same(workspace), any(), any(), any());
@@ -121,7 +121,7 @@ void cycleSingle() {
 
 		// If we transform with the single transformer we should observe an exception due to the detected cycle
 		TransformationManager manager = new TransformationManager(map);
-		TransformationApplier applier = new TransformationApplier(manager, inheritanceGraph, mappingApplier, workspace);
+		TransformationApplier applier = new TransformationApplier(manager, config, inheritanceGraph, mappingApplier, workspace);
 		assertThrows(TransformationException.class, () -> applier.transformJvm(Collections.singletonList(JvmCycleSingle.class)));
 		verify(transformer, never()).transform(any(), same(workspace), any(), any(), any());
 	}
@@ -130,7 +130,7 @@ void cycleSingle() {
 	void missingRegistration() {
 		// If we transform with a transformer that is not registered in the manager, the transform should fail
 		TransformationManager manager = new TransformationManager(Collections.emptyMap());
-		TransformationApplier applier = new TransformationApplier(manager, inheritanceGraph, mappingApplier, workspace);
+		TransformationApplier applier = new TransformationApplier(manager, config, inheritanceGraph, mappingApplier, workspace);
 		assertThrows(TransformationException.class, () -> applier.transformJvm(Collections.singletonList(JvmCycleSingle.class)));
 	}
 

recaf-ui/src/main/resources/translations/en_US.lang

@@ -808,6 +808,7 @@ service.io.resource-importer-config.skip-revisited-cen-to-local-links=Skip dupli
 service.io.resource-importer-config.ignore-file-lengths=Ignore reported file lengths with Naive/Standard strategy
 service.io.resource-importer-config.adapt-standard-cen-file-names=Adopt CEN file names with Standard strategy
 service.io.resource-importer-config.max-embedded-zip-depth=Max embedded zip traversal depth
+service.io.resource-importer-config.parallelize=Enable multi-core input reading
 service.mapping=Mapping
 service.mapping.mapping-aggregator-config=Mapping aggregation
 service.mapping.mapping-formats-config=Mapping formats
@@ -821,6 +822,8 @@ service.plugin.plugin-manager-config=Plugin manager
 service.plugin.plugin-manager-config.scan-on-start=Load on startup
 service.plugin.script-manager-config=Script manager
 service.plugin.script-manager-config.file-watching=Passively scan scripts directory for changes
+service.transform.transformation-applier-config=Transformation Application
+service.transform.transformation-applier-config.parallelize=Enable multi-core transformer application
 service.ui=User interface
 service.ui.bind-config=Bindings
 service.ui.bind-config.bundle=Binding map bundle