faster RemoveParentModule algorithm

sokra · sokra · commit 5db5512849cc · 2017-11-24T18:14:37.000+01:00
diff --git a/lib/optimize/RemoveParentModulesPlugin.js b/lib/optimize/RemoveParentModulesPlugin.js
@@ -4,6 +4,8 @@
 */
 "use strict";
 
+const Queue = require("../util/Queue");
+
 const hasModule = (chunk, module, checkedChunks) => {
 	if(chunk.containsModule(module)) return [chunk];
 	if(chunk.getNumberOfParents() === 0) return false;
@@ -33,30 +35,68 @@ class RemoveParentModulesPlugin {
 	apply(compiler) {
 		compiler.plugin("compilation", (compilation) => {
 			compilation.plugin(["optimize-chunks-basic", "optimize-extracted-chunks-basic"], (chunks) => {
-				for(var index = 0; index < chunks.length; index++) {
-					var chunk = chunks[index];
-					if(chunk.getNumberOfParents() === 0) continue;
+				const queue = new Queue(chunks);
+				const availableModulesMap = new Map();
 
-					// TODO consider Map when performance has improved https://gist.github.com/sokra/b36098368da7b8f6792fd7c85fca6311
-					var cache = Object.create(null);
-					var modules = chunk.getModules();
-					for(var i = 0; i < modules.length; i++) {
-						var module = modules[i];
+				for(const chunk of chunks) {
+					// initialize available modules for chunks without parents
+					if(chunk.getNumberOfParents() === 0)
+						availableModulesMap.set(chunk, new Set());
+				}
 
-						var dId = module.getChunkIdsIdent();
-						var parentChunksWithModule;
-						if(dId === null) {
-							parentChunksWithModule = allHaveModule(chunk.getParents(), module);
-						} else if(dId in cache) {
-							parentChunksWithModule = cache[dId];
-						} else {
-							parentChunksWithModule = cache[dId] = allHaveModule(chunk.getParents(), module);
-						}
-						if(parentChunksWithModule) {
-							module.rewriteChunkInReasons(chunk, Array.from(parentChunksWithModule));
-							chunk.removeModule(module);
+				while(queue.length > 0) {
+					const chunk = queue.dequeue();
+					let availableModules = availableModulesMap.get(chunk);
+					let changed = false;
+					for(const parent of chunk.parentsIterable) {
+						const availableModulesInParent = availableModulesMap.get(parent);
+						if(availableModulesInParent !== undefined) {
+							// If we know the available modules in parent: process these
+							if(availableModules === undefined) {
+								// if we have not own info yet: create new entry
+								availableModules = new Set(availableModulesInParent);
+								for(const m of parent.modulesIterable)
+									availableModules.add(m);
+								availableModulesMap.set(chunk, availableModules);
+								changed = true;
+							} else {
+								for(const m of availableModules) {
+									if(!parent.containsModule(m) && !availableModulesInParent.has(m)) {
+										availableModules.delete(m);
+										changed = true;
+									}
+								}
+							}
 						}
 					}
+					if(changed) {
+						// if something changed: enqueue our children
+						for(const child of chunk.chunksIterable)
+							queue.enqueue(child);
+					}
+				}
+
+				// now we have available modules for every chunk
+
+				for(const chunk of chunks) {
+					// remove modules from chunk if they are already available
+					const availableModules = availableModulesMap.get(chunk);
+					const modules = new Set(chunk.modulesIterable);
+					const toRemove = new Set();
+					if(modules.size < availableModules.size) {
+						for(const m of modules)
+							if(availableModules.has(m))
+								toRemove.add(m);
+					} else {
+						for(const m of availableModules)
+							if(modules.has(m))
+								toRemove.add(m);
+					}
+					for(const module of toRemove) {
+						const parentChunksWithModule = allHaveModule(chunk.getParents(), module);
+						module.rewriteChunkInReasons(chunk, Array.from(parentChunksWithModule));
+						chunk.removeModule(module);
+					}
 				}
 			});
 		});
