Improve initialization of constant pool scanning configuration

In BytecodeTransformerBuildItem, we can define a set of classes which
will be used to determine if a class is affected by a transformation by
by checking the constant pool.

This is most notably (and I think exclusively) used as an optimization
for the Panache transformation of public fields -> accessors.

When you have an application with a lot of entities, all the
BytecodeTransformerBuildItem targeting the classes using these entities
are carrying the Set of all the entities.

And we used copy the Set over and over for each class affected by the
transformation, which was generating a lot of useless allocations.

Obviously, this optimization only works if we don't use the constant
pool scanning optimization for other transformations.

And that why, I ended up adding another optimization: we now only pass
to the transformer the entities we have detected as being used in this
class instead of the whole list of entities.
While doing that should make the first optimization a lot less useful, I
think it's still good to keep it around.

Author: gsmet

core/deployment/src/main/java/io/quarkus/deployment/steps/ClassTransformingBuildStep.java

@@ -16,6 +16,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.Callable;
@@ -101,19 +102,16 @@ TransformedClassesBuildItem handleClassTransformation(List<BytecodeTransformerBu
         for (BytecodeTransformerBuildItem i : bytecodeTransformerBuildItems) {
             bytecodeTransformers.computeIfAbsent(i.getClassToTransform(), (h) -> new ArrayList<>())
                     .add(i);
-            if (i.getRequireConstPoolEntry() == null || i.getRequireConstPoolEntry().isEmpty()) {
-                noConstScanning.add(i.getClassToTransform());
-            } else {
-                constScanning.computeIfAbsent(i.getClassToTransform(), (s) -> new HashSet<>())
-                        .addAll(i.getRequireConstPoolEntry());
-            }
             if (!i.isCacheable()) {
                 nonCacheable.add(i.getClassToTransform());
             }
             classReaderOptions.merge(i.getClassToTransform(), i.getClassReaderOptions(),
                     // class reader options are bit flags (see org.objectweb.asm.ClassReader)
                     (oldValue, newValue) -> oldValue | newValue);
         }
+
+        initializeConstPoolScanningConfiguration(bytecodeTransformers, noConstScanning, constScanning);
+
         QuarkusClassLoader cl = (QuarkusClassLoader) Thread.currentThread().getContextClassLoader();
         Map<String, Path> transformedToArchive = new ConcurrentHashMap<>();
         // now copy all the contents to the runner jar
@@ -288,6 +286,39 @@ public TransformedClassesBuildItem.TransformedClass call() throws Exception {
         return new TransformedClassesBuildItem(transformedClassesByJar);
     }
 
+    private static void initializeConstPoolScanningConfiguration(
+            Map<String, List<BytecodeTransformerBuildItem>> bytecodeTransformers, Set<String> noConstScanning,
+            Map<String, Set<String>> constScanning) {
+        // this option is not widely used and it is mostly used by the Panache transformer AFAIK
+        // in this case, we have all the Panache entities in the list, which might be quite a lot when you have a lot of entities
+        // and it's worth avoiding copying the entries over and over as we used to create a new copy of the set for each entity
+        for (Entry<String, List<BytecodeTransformerBuildItem>> bytecodeTransformersPerClassEntry : bytecodeTransformers
+                .entrySet()) {
+            List<BytecodeTransformerBuildItem> transformersRequiringConstPoolEntries = new ArrayList<>(
+                    bytecodeTransformersPerClassEntry.getValue().size());
+            int requiredConstPoolEntriesNumber = 0;
+            for (BytecodeTransformerBuildItem transformer : bytecodeTransformersPerClassEntry.getValue()) {
+                if (transformer.getRequireConstPoolEntry() != null && !transformer.getRequireConstPoolEntry().isEmpty()) {
+                    transformersRequiringConstPoolEntries.add(transformer);
+                    requiredConstPoolEntriesNumber += transformer.getRequireConstPoolEntry().size();
+                }
+            }
+            if (transformersRequiringConstPoolEntries.isEmpty()) {
+                noConstScanning.add(bytecodeTransformersPerClassEntry.getKey());
+            } else if (transformersRequiringConstPoolEntries.size() == 1) {
+                constScanning.put(bytecodeTransformersPerClassEntry.getKey(),
+                        transformersRequiringConstPoolEntries.get(0).getRequireConstPoolEntry());
+            } else {
+                // we don't do that often, but let's avoid having to resize the underlying HashMap as it can be quite big
+                Set<String> requiredConstPoolEntries = new HashSet<>((int) Math.ceil(requiredConstPoolEntriesNumber / 0.75f));
+                for (BytecodeTransformerBuildItem transformer : transformersRequiringConstPoolEntries) {
+                    requiredConstPoolEntries.addAll(transformer.getRequireConstPoolEntry());
+                }
+                constScanning.put(bytecodeTransformersPerClassEntry.getKey(), requiredConstPoolEntries);
+            }
+        }
+    }
+
     private void copyTransformedClasses(Path originalClassesPath,
             Set<TransformedClassesBuildItem.TransformedClass> transformedClasses) {
         if ((transformedClasses == null) || transformedClasses.isEmpty()) {

extensions/panache/panache-hibernate-common/deployment/src/main/java/io/quarkus/panache/hibernate/common/deployment/PanacheHibernateCommonResourceProcessor.java

@@ -1,7 +1,10 @@
 package io.quarkus.panache.hibernate.common.deployment;
 
 import java.lang.reflect.Modifier;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.Set;
 
@@ -120,34 +123,32 @@ void replaceFieldAccesses(CombinedIndexBuildItem index,
         }
 
         // Replace field access in application code with calls to accessors
-        Set<String> entityClassNamesInternal = new HashSet<>();
-        for (String entityClassName : entitiesWithExternallyAccessibleFields) {
-            entityClassNamesInternal.add(entityClassName.replace(".", "/"));
-        }
-
         PanacheFieldAccessEnhancer panacheFieldAccessEnhancer = new PanacheFieldAccessEnhancer(modelInfo);
-        Set<String> produced = new HashSet<>();
+
+        Map<String, Set<String>> classesUsingEntities = new HashMap<>();
         // transform all users of those classes
         for (String entityClassName : entitiesWithExternallyAccessibleFields) {
             for (ClassInfo userClass : index.getIndex().getKnownUsers(entityClassName)) {
-                String cn = userClass.name().toString('.');
-                if (produced.contains(cn)) {
-                    continue;
-                }
-                produced.add(cn);
-                //The following build item is not marked as CacheAble intentionally: see also https://github.com/quarkusio/quarkus/pull/40192#discussion_r1590605375.
-                //It shouldn't be too hard to improve on this by checking the related entities haven't been changed
-                //via LiveReloadBuildItem (#isLiveReload() && #getChangeInformation()) but I'm not comfortable in making this
-                //change without having solid integration tests.
-                final BytecodeTransformerBuildItem transformation = new BytecodeTransformerBuildItem.Builder()
-                        .setClassToTransform(cn)
-                        .setCacheable(false)//TODO this would be nice to improve on: see note above.
-                        .setVisitorFunction(panacheFieldAccessEnhancer)
-                        .setRequireConstPoolEntry(entityClassNamesInternal)
-                        .build();
-                transformers.produce(transformation);
+                String userClassName = userClass.name().toString('.');
+
+                classesUsingEntities.computeIfAbsent(userClassName, k -> new HashSet<>())
+                        .add(entityClassName.replace(".", "/"));
             }
         }
+
+        for (Entry<String, Set<String>> classUsingEntities : classesUsingEntities.entrySet()) {
+            //The following build item is not marked as CacheAble intentionally: see also https://github.com/quarkusio/quarkus/pull/40192#discussion_r1590605375.
+            //It shouldn't be too hard to improve on this by checking the related entities haven't been changed
+            //via LiveReloadBuildItem (#isLiveReload() && #getChangeInformation()) but I'm not comfortable in making this
+            //change without having solid integration tests.
+            final BytecodeTransformerBuildItem transformation = new BytecodeTransformerBuildItem.Builder()
+                    .setClassToTransform(classUsingEntities.getKey())
+                    .setCacheable(false) // TODO this would be nice to improve on: see note above.
+                    .setVisitorFunction(panacheFieldAccessEnhancer)
+                    .setRequireConstPoolEntry(classUsingEntities.getValue())
+                    .build();
+            transformers.produce(transformation);
+        }
     }
 
     private EntityModel createEntityModel(ClassInfo classInfo) {