Refine performance (alt) (#1508)

Reusing #1492 but simplifying it: copy only the collection that is about to be modified, leave other unchanged (less copy less mem, less cycles).

Author: cstamas

maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/AbstractDependencyManager.java

@@ -51,6 +51,9 @@
  * or applied in same POM) are always applied. This implementation makes sure, that version and scope are not applied
  * onto same node that actually provided the rules, to no override work that ModelBuilder did. It achieves this goal
  * by tracking "depth" for each collected rule and ignoring rules coming from same depth as processed dependency node is.
+ * <p>
+ * Note for future: the field {@code managedLocalPaths} is <em>intentionally left out of hash/equals</em>, with
+ * reason explained above.
  *
  * @since 2.0.0
  */
@@ -113,15 +116,8 @@ protected AbstractDependencyManager(
         // nullable: if using scope manager, but there is no system scope defined
         this.systemDependencyScope = systemDependencyScope;
 
-        this.hashCode = Objects.hash(
-                depth,
-                deriveUntil,
-                applyFrom,
-                managedVersions,
-                managedScopes,
-                managedOptionals,
-                managedLocalPaths,
-                managedExclusions);
+        // exclude managedLocalPaths
+        this.hashCode = Objects.hash(depth, managedVersions, managedScopes, managedOptionals, managedExclusions);
     }
 
     protected abstract DependencyManager newInstance(
@@ -185,7 +181,7 @@ public DependencyManager deriveChildManager(DependencyCollectionContext context)
             Collection<Exclusion> exclusions = managedDependency.getExclusions();
             if (!exclusions.isEmpty()) {
                 if (managedExclusions == this.managedExclusions) {
-                    managedExclusions = MMap.copy(this.managedExclusions);
+                    managedExclusions = MMap.copyWithKey(key, this.managedExclusions);
                 }
                 Collection<Holder<Collection<Exclusion>>> managed = managedExclusions.get(key);
                 if (managed == null) {
@@ -320,13 +316,11 @@ public boolean equals(Object obj) {
         }
 
         AbstractDependencyManager that = (AbstractDependencyManager) obj;
+        // exclude managedLocalPaths
         return depth == that.depth
-                && deriveUntil == that.deriveUntil
-                && applyFrom == that.applyFrom
                 && managedVersions.equals(that.managedVersions)
                 && managedScopes.equals(that.managedScopes)
                 && managedOptionals.equals(that.managedOptionals)
-                && managedLocalPaths.equals(that.managedLocalPaths)
                 && managedExclusions.equals(that.managedExclusions);
     }
 

maven-resolver-util/src/main/java/org/eclipse/aether/util/graph/manager/MMap.java

@@ -18,6 +18,8 @@
  */
 package org.eclipse.aether.util.graph.manager;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 
 /**
@@ -47,6 +49,12 @@ public static <K, V> MMap<K, V> copy(MMap<K, V> orig) {
         return new MMap<>(new HashMap<>(orig.delegate));
     }
 
+    public static <K, V> MMap<K, Collection<V>> copyWithKey(K key, MMap<K, Collection<V>> orig) {
+        HashMap<K, Collection<V>> delegateLocal = new HashMap<>(orig.delegate);
+        delegateLocal.computeIfPresent(key, (k, v) -> new ArrayList<>(v));
+        return new MMap<>(delegateLocal);
+    }
+
     protected final HashMap<K, V> delegate;
 
     private MMap(HashMap<K, V> delegate) {