Attempt to reduce overhead of splitting same path string many times

Author: embeddedt

common/src/main/java/org/embeddedt/modernfix/resources/PackResourcesCacheEngine.java

@@ -16,6 +16,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
@@ -24,6 +25,8 @@
  */
 public class PackResourcesCacheEngine {
     private static final Joiner SLASH_JOINER = Joiner.on('/');
+    private static final ConcurrentHashMap<String, String> PATH_COMPONENT_INTERNER = new ConcurrentHashMap<>();
+    private static final ConcurrentHashMap<String, String[]> CACHED_SPLIT_PATHS = new ConcurrentHashMap<>();
 
     static class Node {
         Map<String, Node> children;
@@ -100,7 +103,6 @@ public PackResourcesCacheEngine(Function<PackType, Path> basePathRetriever) {
         // used for log message
         this.debugPath = basePathRetriever.apply(PackType.CLIENT_RESOURCES).toAbsolutePath();
         this.root.children = new Object2ObjectOpenHashMap<>();
-        ObjectOpenHashSet<String> pathKeys = new ObjectOpenHashSet<>();
         for(PackType type : PackType.values()) {
             var typeRoot = new Node();
             this.root.children.put(type.getDirectory(), typeRoot);
@@ -114,8 +116,12 @@ public PackResourcesCacheEngine(Function<PackType, Path> basePathRetriever) {
                                 .filter(PackResourcesCacheEngine::isValidCachedResourcePath)
                                 .forEach(path -> {
                                     var node = typeRoot;
-                                    for (Path component : path) {
-                                        String key = pathKeys.addOrGet(component.toString());
+                                    int nameCount = path.getNameCount();
+                                    for (int i = 0; i < nameCount; i++) {
+                                        String key = path.getName(i).toString();
+                                        if (i < (nameCount - 1)) {
+                                            key = PATH_COMPONENT_INTERNER.computeIfAbsent(key, Function.identity());
+                                        }
                                         if (node.children == null) {
                                             node.children = new Object2ObjectOpenHashMap<>();
                                         }
@@ -205,4 +211,16 @@ public void collectResources(PackType type, String resourceNamespace, String[] c
         }
         node.collectResources(resourceNamespace, this.rootPathsByType.get(type).resolve(resourceNamespace), components, 0, maxDepth, output);
     }
+
+    private static String[] decompose(String path) {
+        String[] components = path.split("/");
+        for (int i = 0; i < components.length; i++) {
+            components[i] = PATH_COMPONENT_INTERNER.computeIfAbsent(components[i], Function.identity());
+        }
+        return components;
+    }
+
+    public static String[] decomposeCached(String path) {
+        return CACHED_SPLIT_PATHS.computeIfAbsent(path, PackResourcesCacheEngine::decompose);
+    }
 }

forge/src/main/java/org/embeddedt/modernfix/forge/mixin/perf/resourcepacks/ForgePathPackResourcesMixin.java

@@ -102,6 +102,6 @@ private void fastGetResources(PackType type, String namespace, String path, Pack
         if(!PackTypeHelper.isVanillaPackType(type))
             return;
         ci.cancel();
-        this.generateResourceCache().collectResources(type, namespace, path.split("/"), Integer.MAX_VALUE, resourceOutput);
+        this.generateResourceCache().collectResources(type, namespace, PackResourcesCacheEngine.decomposeCached(path), Integer.MAX_VALUE, resourceOutput);
     }
 }