[Maven] Introduce BTA classloader cache

Increases metaspace limit in the test to allow 2 classloader to be created
^KT-81435 Verification Pending

Author: ALikhachev

libraries/tools/kotlin-maven-plugin-test/src/it/test-multimodule-in-process/invoker.properties

@@ -1 +1,4 @@
-invoker.environmentVariables.MAVEN_OPTS = -XX:MaxMetaspaceSize=150M
+# enough for 2 compiler classloaders
+invoker.environmentVariables.MAVEN_OPTS = -XX:MaxMetaspaceSize=300M
+# capture classloader creation lines from debug logs
+invoker.debug = true

libraries/tools/kotlin-maven-plugin-test/src/it/test-multimodule-in-process/module2/pom.xml

@@ -29,6 +29,21 @@
                         </goals>
                     </execution>
                 </executions>
+
+                <!-- Apply a compiler plugin. It should currently lead to the creation of another classloader -->
+                <configuration>
+                    <compilerPlugins>
+                       <plugin>all-open</plugin>
+                    </compilerPlugins>
+                </configuration>
+
+                <dependencies>
+                    <dependency>
+                        <groupId>org.jetbrains.kotlin</groupId>
+                        <artifactId>kotlin-maven-allopen</artifactId>
+                        <version>${kotlin.version}</version>
+                    </dependency>
+                </dependencies>
             </plugin>
         </plugins>
     </build>

libraries/tools/kotlin-maven-plugin-test/src/it/test-multimodule-in-process/module3/pom.xml

@@ -30,6 +30,12 @@
                     </execution>
                 </executions>
             </plugin>
+            <!-- Apply another plugin to ensure it does not affect the compiler classloader -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-source-plugin</artifactId>
+                <version>2.1.2</version>
+            </plugin>
         </plugins>
     </build>
 

libraries/tools/kotlin-maven-plugin-test/src/it/test-multimodule-in-process/verify.groovy

@@ -0,0 +1,8 @@
+def buildLogFile = new File(basedir, "build.log")
+
+def lines = buildLogFile.readLines()
+def createdClassloaders = lines.count { it.startsWith("[DEBUG] Creating classloader") }
+
+// 1 classloader for modules 1, 3, 4, 5
+// 2 classloader for module 2 with a compiler plugin
+return createdClassloaders == 2

libraries/tools/kotlin-maven-plugin/pom.xml

@@ -82,6 +82,16 @@
             <version>1</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>33.5.0-jre</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>26.0.2-1</version>
+        </dependency>
     </dependencies>
 
     <build>

libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/ClassLoaderCache.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2010-2025 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.maven;
+
+import com.google.common.cache.Cache;
+import com.google.common.cache.CacheBuilder;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.buildtools.api.SharedApiClassesClassLoader;
+
+import java.io.File;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A static holder for a thread-safe cache of class loaders.
+ * Persists the cache between builds and different mojos using the same build process unless a different classloader is used for loading the Maven plugin.
+ * In such cases, the remaining cache is garbage collected with the related class loader.
+ * The cache utilizes a combination of time-based eviction and soft references for efficient resource usage.
+ * Almost copied "as is" from KGP's `ClassLoadersCacheHolder`
+ */
+class ClassLoaderCache {
+    static class ClassLoaderCacheKey {
+        private final List<File> classpath;
+        private final ParentClassLoaderProvider parentClassLoaderProvider;
+
+        ClassLoaderCacheKey(List<File> classpath, ParentClassLoaderProvider parentClassLoaderProvider) {
+            this.classpath = classpath;
+            this.parentClassLoaderProvider = parentClassLoaderProvider;
+        }
+
+        @Override
+        public boolean equals(Object o) {
+            if (o == null || getClass() != o.getClass()) return false;
+            ClassLoaderCacheKey key = (ClassLoaderCacheKey) o;
+            return Objects.equals(classpath, key.classpath) &&
+                   Objects.equals(parentClassLoaderProvider, key.parentClassLoaderProvider);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(classpath, parentClassLoaderProvider);
+        }
+
+        public List<File> getClasspath() {
+            return classpath;
+        }
+
+        public ParentClassLoaderProvider getParentClassLoaderProvider() {
+            return parentClassLoaderProvider;
+        }
+    }
+
+    /**
+     * The cache can be accessed by multiple compilations concurrently, hence the cache must be thread-safe.
+     * As per `com.google.common.cache.Cache` documentation, implementations are expected to be thread-safe.
+     * Utilizes the double-check locking singleton pattern, so @Volatile is crucial for correctness.
+     */
+    private static volatile Cache<@NotNull ClassLoaderCacheKey, @NotNull ClassLoader> classLoaders;
+    private static final Object lock = new Object();
+
+    static Cache<@NotNull ClassLoaderCacheKey, @NotNull ClassLoader> getCache(Long classLoaderCacheTimeoutInSeconds) {
+        if (classLoaders == null) {
+            synchronized(lock) {
+                if (classLoaders == null) {
+                    classLoaders = CacheBuilder.newBuilder()
+                                           .expireAfterAccess(classLoaderCacheTimeoutInSeconds, TimeUnit.SECONDS)
+                                           .softValues()
+                                           .build();
+                }
+            }
+        }
+        return classLoaders;
+    }
+}
+
+/**
+ * A provider of the parent [ClassLoader] for newly created ClassLoader instances.
+ * <p>
+ * An implementation must override `equals` and `hashCode`! It's used as a part of a {@link Cache} key
+ */
+interface ParentClassLoaderProvider {
+    ClassLoader getClassLoader();
+}
+
+class SharedBuildToolsApiClassesClassLoaderProvider implements ParentClassLoaderProvider {
+    @Override
+    public ClassLoader getClassLoader() {
+        return SharedApiClassesClassLoader.newInstance();
+    }
+
+    @Override
+    public int hashCode() {
+        return SharedBuildToolsApiClassesClassLoaderProvider.class.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof SharedBuildToolsApiClassesClassLoaderProvider;
+    }
+}

libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/K2JVMCompileMojo.java

@@ -48,6 +48,7 @@
 import java.nio.file.Paths;
 import java.time.Duration;
 import java.util.*;
+import java.util.concurrent.ExecutionException;
 import java.util.function.Consumer;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
@@ -102,6 +103,12 @@ public class K2JVMCompileMojo extends KotlinCompileMojoBase<K2JVMCompilerArgumen
     @Parameter(property = "kotlin.compiler.daemon", defaultValue = "true")
     protected boolean useDaemon;
 
+    @Parameter(property = "kotlin.compiler.classloader.cache.timeoutSeconds")
+    @Nullable
+    protected Long classLoaderCacheTimeoutSeconds;
+
+    private static final Duration DEFAULT_CLASSLOADER_CACHE_TIMEOUT = Duration.ofMinutes(30);
+
     @Parameter(property = "kotlin.compiler.daemon.jvmArgs")
     protected List<String> kotlinDaemonJvmArgs;
 
@@ -260,19 +267,36 @@ private KotlinToolchains getKotlinToolchains() throws MojoExecutionException {
                             kotlinArtifactResolver.resolveArtifact("org.jetbrains.kotlin", "kotlin-build-tools-impl", getMavenPluginVersion()).stream(),
                             kotlinArtifactResolver.resolveArtifact("org.jetbrains.kotlin", "kotlin-scripting-compiler-embeddable", getMavenPluginVersion()).stream()
                     ).collect(Collectors.toCollection(LinkedHashSet::new));
-            URL[] urls = artifacts.stream().map(artifact -> {
-                File file = artifact.getFile();
-                try {
-                    return file.toURI().toURL();
-                }
-                catch (MalformedURLException e) {
-                    throw new RuntimeException("Failed to convert file to URL: " + file, e);
-                }
-            }).toArray(URL[]::new);
-            ClassLoader btaClassLoader = new URLClassLoader(urls, SharedApiClassesClassLoader.newInstance());
+            List<File> files = artifacts.stream().map(Artifact::getFile).collect(Collectors.toList());
+            ClassLoader btaClassLoader = getBtaClassLoader(files);
             return KotlinToolchains.loadImplementation(btaClassLoader);
-        } catch (Exception e) {
-            throw new MojoExecutionException("Failed to load Kotlin Build Tools API implementation", e);
+        } catch (Throwable t) {
+            throw new MojoExecutionException("Failed to load Kotlin Build Tools API implementation", t);
+        }
+    }
+
+    private ClassLoader getBtaClassLoader(List<File> files) {
+        ClassLoaderCache.ClassLoaderCacheKey cacheKey =
+                new ClassLoaderCache.ClassLoaderCacheKey(files, new SharedBuildToolsApiClassesClassLoaderProvider());
+        try {
+            long cacheTimeout = classLoaderCacheTimeoutSeconds == null
+                                ? DEFAULT_CLASSLOADER_CACHE_TIMEOUT.getSeconds()
+                                : classLoaderCacheTimeoutSeconds;
+            return ClassLoaderCache.getCache(cacheTimeout).get(cacheKey, () -> {
+                getLog().debug("Creating classloader for " + cacheKey.getClasspath());
+                URL[] urls = cacheKey.getClasspath().stream().map(file -> {
+                    try {
+                        return file.toURI().toURL();
+                    }
+                    catch (MalformedURLException e) {
+                        throw new RuntimeException(e);
+                    }
+                }).toArray(URL[]::new);
+                return new URLClassLoader(urls, cacheKey.getParentClassLoaderProvider().getClassLoader());
+            });
+        }
+        catch (ExecutionException e) {
+            throw new RuntimeException(e);
         }
     }
 

repo/artifacts-tests/src/test/resources/org/jetbrains/kotlin/kotlin-maven-plugin/kotlin-maven-plugin.pom

@@ -82,6 +82,16 @@
             <version>1</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>33.5.0-jre</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains</groupId>
+            <artifactId>annotations</artifactId>
+            <version>26.0.2-1</version>
+        </dependency>
     </dependencies>
 
     <build>