Improve Maven cache architecture for better memory efficiency and performance

This comprehensive enhancement to Maven's caching system addresses memory issues
and significantly improves performance through several key improvements:

## Key Features:
- Enhanced DefaultRequestCache with configurable reference types and CSS-like selectors
- Pluggable ModelObjectPool service architecture with configurable object types
- Comprehensive cache statistics with eviction tracking
- Improved InputLocation and InputSource with ImmutableCollections
- Custom equality strategy for Dependency pooling
- Enhanced parent request matching with interface checking
- Configurable cache statistics display

## Performance Results:
- Maven 3: Requires -Xmx1536m, runs in 45 seconds
- Maven 4.0.0-rc-4: Runs with -Xmx1024m in 2'32" (cannot run with -Xmx512m)
- Maven 4.0.0-rc-4 with -Xmx1536m: 2'5"
- Maven 4.0.0-rc-4 + maven3Personality with -Xmx1536m: 1'14"
- Maven 4 + this PR: Runs with -Xmx512m in 3'42" (more memory does not help)
- Maven 4 + this PR + maven3Personality: Runs with -Xmx512m in 1'0"

## Memory Improvements:
- Reduced minimum memory requirement from 1024m to 512m
- Eliminated memory scaling issues - additional memory beyond 512m provides no benefit
- Significant reduction in memory pressure through improved caching strategies

This PR definitively solves memory problems while maintaining or improving performance.

Author: gnodet

api/maven-api-core/src/main/java/org/apache/maven/api/Constants.java

@@ -622,5 +622,66 @@ public final class Constants {
      */
     public static final String MAVEN_LOGGER_LOG_PREFIX = MAVEN_LOGGER_PREFIX + "log.";
 
+    /**
+     * User property key for cache configuration.
+     *
+     * @since 4.1.0
+     */
+    public static final String MAVEN_CACHE_CONFIG_PROPERTY = "maven.cache.config";
+
+    /**
+     * User property to enable cache statistics display at the end of the build.
+     * When set to true, detailed cache statistics including hit/miss ratios,
+     * request type breakdowns, and retention policy effectiveness will be displayed
+     * when the build completes.
+     *
+     * @since 4.1.0
+     */
+    @Config(type = "java.lang.Boolean", defaultValue = "false")
+    public static final String MAVEN_CACHE_STATS = "maven.cache.stats";
+
+    /**
+     * User property to configure separate reference types for cache keys and values.
+     * Format: "key:value" where key and value can be NONE, SOFT, WEAK, or HARD.
+     * Examples:
+     * - "HARD:SOFT" - Keep keys strongly referenced, allow values to be garbage collected under memory pressure
+     * - "WEAK:WEAK" - Allow both keys and values to be garbage collected aggressively
+     * - "SOFT:HARD" - Allow keys to be GC'd under memory pressure, keep values strongly referenced
+     *
+     * This enables fine-grained analysis of cache misses caused by key vs value evictions.
+     *
+     * @since 4.1.0
+     */
+    public static final String MAVEN_CACHE_KEY_VALUE_REFS = "maven.cache.keyValueRefs";
+
+    /**
+     * User property key for configuring which object types are pooled by ModelObjectProcessor.
+     * Value should be a comma-separated list of simple class names (e.g., "Dependency,Plugin,Build").
+     * Default is "Dependency" for backward compatibility.
+     *
+     * @since 4.1.0
+     */
+    @Config(defaultValue = "Dependency")
+    public static final String MAVEN_MODEL_PROCESSOR_POOLED_TYPES = "maven.model.processor.pooledTypes";
+
+    /**
+     * User property key for configuring the default reference type used by ModelObjectProcessor.
+     * Valid values are: "SOFT", "HARD", "WEAK", "NONE".
+     * Default is "HARD" for optimal performance.
+     *
+     * @since 4.1.0
+     */
+    @Config(defaultValue = "HARD")
+    public static final String MAVEN_MODEL_PROCESSOR_REFERENCE_TYPE = "maven.model.processor.referenceType";
+
+    /**
+     * User property key prefix for configuring per-object-type reference types.
+     * Format: maven.model.processor.referenceType.{ClassName} = {ReferenceType}
+     * Example: maven.model.processor.referenceType.Dependency = SOFT
+     *
+     * @since 4.1.0
+     */
+    public static final String MAVEN_MODEL_PROCESSOR_REFERENCE_TYPE_PREFIX = "maven.model.processor.referenceType.";
+
     private Constants() {}
 }

api/maven-api-model/src/main/java/org/apache/maven/api/model/InputLocation.java

@@ -20,9 +20,9 @@
 
 import java.io.Serializable;
 import java.util.Collection;
-import java.util.Collections;
 import java.util.LinkedHashMap;
 import java.util.Map;
+import java.util.Objects;
 
 /**
  * Represents the location of an element within a model source file.
@@ -40,11 +40,15 @@ public class InputLocation implements Serializable, InputLocationTracker {
     private final Map<Object, InputLocation> locations;
     private final InputLocation importedFrom;
 
+    private volatile int hashCode = 0; // Cached hashCode for performance
+
+    private static final InputLocation EMPTY = new InputLocation(-1, -1);
+
     public InputLocation(InputSource source) {
         this.lineNumber = -1;
         this.columnNumber = -1;
         this.source = source;
-        this.locations = Collections.singletonMap(0, this);
+        this.locations = ImmutableCollections.singletonMap(0, this);
         this.importedFrom = null;
     }
 
@@ -60,8 +64,9 @@ public InputLocation(int lineNumber, int columnNumber, InputSource source, Objec
         this.lineNumber = lineNumber;
         this.columnNumber = columnNumber;
         this.source = source;
-        this.locations =
-                selfLocationKey != null ? Collections.singletonMap(selfLocationKey, this) : Collections.emptyMap();
+        this.locations = selfLocationKey != null
+                ? ImmutableCollections.singletonMap(selfLocationKey, this)
+                : ImmutableCollections.emptyMap();
         this.importedFrom = null;
     }
 
@@ -73,12 +78,75 @@ public InputLocation(int lineNumber, int columnNumber, InputSource source, Map<O
         this.importedFrom = null;
     }
 
-    public InputLocation(InputLocation original) {
-        this.lineNumber = original.lineNumber;
-        this.columnNumber = original.columnNumber;
-        this.source = original.source;
-        this.locations = original.locations;
-        this.importedFrom = original.importedFrom;
+    // Factory methods
+
+    public static InputLocation of() {
+        return EMPTY;
+    }
+
+    /**
+     * Creates a new InputLocation with the specified source.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param source the input source
+     * @return a new InputLocation instance
+     */
+    public static InputLocation of(InputSource source) {
+        return ModelObjectProcessor.processObject(new InputLocation(source));
+    }
+
+    /**
+     * Creates a new InputLocation with the specified line and column numbers.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param lineNumber the line number
+     * @param columnNumber the column number
+     * @return a new InputLocation instance
+     */
+    public static InputLocation of(int lineNumber, int columnNumber) {
+        return ModelObjectProcessor.processObject(new InputLocation(lineNumber, columnNumber));
+    }
+
+    /**
+     * Creates a new InputLocation with the specified line number, column number, and source.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param lineNumber the line number
+     * @param columnNumber the column number
+     * @param source the input source
+     * @return a new InputLocation instance
+     */
+    public static InputLocation of(int lineNumber, int columnNumber, InputSource source) {
+        return ModelObjectProcessor.processObject(new InputLocation(lineNumber, columnNumber, source));
+    }
+
+    /**
+     * Creates a new InputLocation with the specified line number, column number, source, and self location key.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param lineNumber the line number
+     * @param columnNumber the column number
+     * @param source the input source
+     * @param selfLocationKey the self location key
+     * @return a new InputLocation instance
+     */
+    public static InputLocation of(int lineNumber, int columnNumber, InputSource source, Object selfLocationKey) {
+        return ModelObjectProcessor.processObject(new InputLocation(lineNumber, columnNumber, source, selfLocationKey));
+    }
+
+    /**
+     * Creates a new InputLocation with the specified line number, column number, source, and locations map.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param lineNumber the line number
+     * @param columnNumber the column number
+     * @param source the input source
+     * @param locations the locations map
+     * @return a new InputLocation instance
+     */
+    public static InputLocation of(
+            int lineNumber, int columnNumber, InputSource source, Map<Object, InputLocation> locations) {
+        return ModelObjectProcessor.processObject(new InputLocation(lineNumber, columnNumber, source, locations));
     }
 
     public int getLineNumber() {
@@ -184,21 +252,83 @@ public static InputLocation merge(InputLocation target, InputLocation source, Co
         return new InputLocation(-1, -1, InputSource.merge(source.getSource(), target.getSource()), locations);
     } // -- InputLocation merge( InputLocation, InputLocation, java.util.Collection )
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        InputLocation that = (InputLocation) o;
+        return lineNumber == that.lineNumber
+                && columnNumber == that.columnNumber
+                && Objects.equals(source, that.source)
+                && safeLocationsEquals(this, locations, that, that.locations)
+                && Objects.equals(importedFrom, that.importedFrom);
+    }
+
     /**
-     * Class StringFormatter.
-     *
-     * @version $Revision$ $Date$
+     * Safely compares two locations maps, treating self-references as equal.
      */
-    public interface StringFormatter {
+    private static boolean safeLocationsEquals(
+            InputLocation this1,
+            Map<Object, InputLocation> map1,
+            InputLocation this2,
+            Map<Object, InputLocation> map2) {
+        if (map1 == map2) {
+            return true;
+        }
+        if (map1 == null || map2 == null) {
+            return false;
+        }
+        if (map1.size() != map2.size()) {
+            return false;
+        }
 
-        // -----------/
-        // - Methods -/
-        // -----------/
+        for (Map.Entry<Object, InputLocation> entry1 : map1.entrySet()) {
+            Object key = entry1.getKey();
+            InputLocation value1 = entry1.getValue();
+            InputLocation value2 = map2.get(key);
 
-        /**
-         * Method toString.
-         */
-        String toString(InputLocation location);
+            if (value1 == this1) {
+                if (value2 == this2) {
+                    continue;
+                }
+                return false;
+            } else {
+                if (Objects.equals(value1, value2)) {
+                    continue;
+                }
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = hashCode;
+        if (result == 0) {
+            result = Objects.hash(lineNumber, columnNumber, source, safeHash(locations), importedFrom);
+            hashCode = result;
+        }
+        return result;
+    }
+
+    public int safeHash(Map<Object, InputLocation> locations) {
+        if (locations == null) {
+            return 0;
+        }
+        int result = 1;
+        for (Map.Entry<Object, InputLocation> entry : locations.entrySet()) {
+            result = 31 * result + Objects.hashCode(entry.getKey());
+            if (entry.getValue() != this) {
+                result = 31 * result + Objects.hashCode(entry.getValue());
+            }
+        }
+        return result;
     }
 
     @Override

api/maven-api-model/src/main/java/org/apache/maven/api/model/InputSource.java

@@ -41,6 +41,8 @@ public class InputSource implements Serializable {
     private final List<InputSource> inputs;
     private final InputLocation importedFrom;
 
+    private volatile int hashCode = 0; // Cached hashCode for performance
+
     public InputSource(String modelId, String location) {
         this(modelId, location, null);
     }
@@ -59,6 +61,44 @@ public InputSource(Collection<InputSource> inputs) {
         this.importedFrom = null;
     }
 
+    // Factory methods
+
+    /**
+     * Creates a new InputSource with the specified model ID and location.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param modelId the model ID
+     * @param location the location
+     * @return a new InputSource instance
+     */
+    public static InputSource of(String modelId, String location) {
+        return ModelObjectProcessor.processObject(new InputSource(modelId, location));
+    }
+
+    /**
+     * Creates a new InputSource with the specified model ID, location, and imported from location.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param modelId the model ID
+     * @param location the location
+     * @param importedFrom the imported from location
+     * @return a new InputSource instance
+     */
+    public static InputSource of(String modelId, String location, InputLocation importedFrom) {
+        return ModelObjectProcessor.processObject(new InputSource(modelId, location, importedFrom));
+    }
+
+    /**
+     * Creates a new InputSource from a collection of input sources.
+     * The created instance is processed through ModelObjectProcessor for optimization.
+     *
+     * @param inputs the collection of input sources
+     * @return a new InputSource instance
+     */
+    public static InputSource of(Collection<InputSource> inputs) {
+        return ModelObjectProcessor.processObject(new InputSource(inputs));
+    }
+
     /**
      * Get the path/URL of the POM or {@code null} if unknown.
      *
@@ -99,12 +139,18 @@ public boolean equals(Object o) {
         InputSource that = (InputSource) o;
         return Objects.equals(modelId, that.modelId)
                 && Objects.equals(location, that.location)
-                && Objects.equals(inputs, that.inputs);
+                && Objects.equals(inputs, that.inputs)
+                && Objects.equals(importedFrom, that.importedFrom);
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(modelId, location, inputs);
+        int result = hashCode;
+        if (result == 0) {
+            result = Objects.hash(modelId, location, inputs, importedFrom);
+            hashCode = result;
+        }
+        return result;
     }
 
     Stream<InputSource> sources() {
@@ -120,6 +166,7 @@ public String toString() {
     }
 
     public static InputSource merge(InputSource src1, InputSource src2) {
-        return new InputSource(Stream.concat(src1.sources(), src2.sources()).collect(Collectors.toSet()));
+        return new InputSource(
+                Stream.concat(src1.sources(), src2.sources()).distinct().toList());
     }
 }