Change output to group by jar

Author: jormundur00

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/AnalyzeMethodsRequiringMetadataUsageFeature.java

@@ -41,7 +41,7 @@
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.Collections;
-import java.util.Comparator;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Objects;
 import java.util.Set;
@@ -60,71 +60,54 @@ public final class AnalyzeMethodsRequiringMetadataUsageFeature implements Intern
     public static final String METHODTYPE_RESOURCE = "resource";
     public static final String METHODTYPE_SERIALIZATION = "serialization";
     public static final String METHODTYPE_PROXY = "proxy";
-    private final Map<String, List<String>> reflectiveCalls;
-    private final Map<String, List<String>> resourceCalls;
-    private final Map<String, List<String>> serializationCalls;
-    private final Map<String, List<String>> proxyCalls;
     private final Set<String> jarPaths;
+    private final Map<String, Map<String, Map<String, List<String>>>> callsByJar;
     private final Set<FoldEntry> foldEntries = ConcurrentHashMap.newKeySet();
 
     public AnalyzeMethodsRequiringMetadataUsageFeature() {
-        this.reflectiveCalls = new TreeMap<>();
-        this.resourceCalls = new TreeMap<>();
-        this.serializationCalls = new TreeMap<>();
-        this.proxyCalls = new TreeMap<>();
+        this.callsByJar = new ConcurrentHashMap<>();
         this.jarPaths = Collections.unmodifiableSet(new HashSet<>(AnalyzeMethodsRequiringMetadataUsageFeature.Options.TrackMethodsRequiringMetadata.getValue().values()));
     }
 
     public static AnalyzeMethodsRequiringMetadataUsageFeature instance() {
         return ImageSingletons.lookup(AnalyzeMethodsRequiringMetadataUsageFeature.class);
     }
 
-    public void addCall(String methodType, String call, String callLocation) {
-        switch (methodType) {
-            case METHODTYPE_REFLECTION -> this.reflectiveCalls.computeIfAbsent(call, k -> new ArrayList<>()).add(callLocation);
-            case METHODTYPE_RESOURCE -> this.resourceCalls.computeIfAbsent(call, k -> new ArrayList<>()).add(callLocation);
-            case METHODTYPE_SERIALIZATION -> this.serializationCalls.computeIfAbsent(call, k -> new ArrayList<>()).add(callLocation);
-            case METHODTYPE_PROXY -> this.proxyCalls.computeIfAbsent(call, k -> new ArrayList<>()).add(callLocation);
-            default -> throw new IllegalArgumentException("Unknown method type: " + methodType);
-        }
+    public void addCall(String jarPath, String methodType, String call, String callLocation) {
+        this.callsByJar.computeIfAbsent(jarPath, k -> new HashMap<>());
+        this.callsByJar.get(jarPath).computeIfAbsent(methodType, k -> new TreeMap<>());
+        this.callsByJar.get(jarPath).get(methodType).computeIfAbsent(call, k -> new ArrayList<>());
+        this.callsByJar.get(jarPath).get(methodType).get(call).add(callLocation);
     }
 
-    public void printReport(String methodType) {
-        Map<String, List<String>> callMap = switch (methodType) {
-            case METHODTYPE_REFLECTION -> this.reflectiveCalls;
-            case METHODTYPE_RESOURCE -> this.resourceCalls;
-            case METHODTYPE_SERIALIZATION -> this.serializationCalls;
-            case METHODTYPE_PROXY -> this.proxyCalls;
-            default -> throw new IllegalArgumentException("Unknown method type: " + methodType);
-        };
-
-        System.out.println(methodType.substring(0, 1).toUpperCase() + methodType.substring(1) + " calls detected:");
-        for (String key : callMap.keySet()) {
-            System.out.println("    " + key + ":");
-            callMap.get(key).sort(Comparator.comparing(String::toString));
-            for (String callLocation : callMap.get(key)) {
-                System.out.println("        at " + callLocation);
+    public void printReportForJar(String jarPath) {
+        System.out.println("Dynamic method usage detected in " + jarPath + ":");
+        for (String methodType : callsByJar.get(jarPath).keySet()) {
+            System.out.println("    " + methodType.substring(0, 1).toUpperCase() + methodType.substring(1) + " calls detected:");
+            for (String call : callsByJar.get(jarPath).get(methodType).keySet()) {
+                System.out.println("        " + call + ":");
+                for (String callLocation : callsByJar.get(jarPath).get(methodType).get(call)) {
+                    System.out.println("            at " + callLocation);
+                }
             }
         }
     }
 
-    public void dumpReport(String methodType) {
-        Map<String, List<String>> calls = switch (methodType) {
-            case METHODTYPE_REFLECTION -> this.reflectiveCalls;
-            case METHODTYPE_RESOURCE -> this.resourceCalls;
-            case METHODTYPE_SERIALIZATION -> this.serializationCalls;
-            case METHODTYPE_PROXY -> this.proxyCalls;
-            default -> throw new IllegalArgumentException("Unknown method type: " + methodType);
-        };
-        String fileName = methodType + "-usage.json";
-
+    public void dumpReportForJar(String jarPath) {
+        String fileName = extractLibraryName(jarPath) + "-method-calls.json";
+        Map<String, Map<String, List<String>>> calls = callsByJar.get(jarPath);
         Path targetPath = NativeImageGenerator.generatedFiles(HostedOptionValues.singleton()).resolve(fileName);
         try (var writer = new JsonWriter(targetPath);
                         var builder = writer.objectBuilder()) {
-            for (Map.Entry<String, List<String>> entry : calls.entrySet()) {
-                try (JsonBuilder.ArrayBuilder array = builder.append(entry.getKey()).array()) {
-                    for (String call : entry.getValue()) {
-                        array.append(call);
+            for (Map.Entry<String, Map<String, List<String>>> callEntry : calls.entrySet()) {
+                try (JsonBuilder.ObjectBuilder methodsByTypeBuilder = builder.append(callEntry.getKey()).object()) {
+                    Map<String, List<String>> nestedMap = callEntry.getValue();
+                    for (Map.Entry<String, List<String>> entry : nestedMap.entrySet()) {
+                        try (JsonBuilder.ArrayBuilder array = methodsByTypeBuilder.append(entry.getKey()).array()) {
+                            for (String call : entry.getValue()) {
+                                array.append(call);
+                            }
+                        }
                     }
                 }
             }
@@ -136,25 +119,26 @@ public void dumpReport(String methodType) {
     }
 
     public void reportMethodUsage() {
-        Map<String, Map<String, List<String>>> callMaps = Map.of(
-                        METHODTYPE_REFLECTION, this.reflectiveCalls,
-                        METHODTYPE_RESOURCE, this.resourceCalls,
-                        METHODTYPE_SERIALIZATION, this.serializationCalls,
-                        METHODTYPE_PROXY, this.proxyCalls);
-        for (Map.Entry<String, Map<String, List<String>>> entry : callMaps.entrySet()) {
-            String methodType = entry.getKey();
-            Map<String, List<String>> calls = entry.getValue();
-            if (!calls.isEmpty()) {
-                printReport(methodType);
-                dumpReport(methodType);
-            }
+        for (String jarPath : jarPaths) {
+            printReportForJar(jarPath);
+            dumpReportForJar(jarPath);
         }
     }
 
     public Set<String> getJarPaths() {
         return jarPaths;
     }
 
+    public String extractLibraryName(String path) {
+        String fileName = path.substring(path.lastIndexOf("/") + 1);
+
+        if (fileName.endsWith(".jar")) {
+            fileName = fileName.substring(0, fileName.length() - 4);
+        }
+
+        return fileName;
+    }
+
     /*
      * Support data structure used to keep track of calls which don't require metadata, but can't be
      * folded.

substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/phases/AnalyzeMethodsRequiringMetadataUsagePhase.java

@@ -193,7 +193,7 @@ protected void run(StructuredGraph graph, CoreProviders context) {
                     int bci = nspToShow.getBCI();
                     if (!AnalyzeMethodsRequiringMetadataUsageFeature.instance().containsFoldEntry(bci, nspToShow.getMethod())) {
                         String callLocation = nspToShow.getMethod().asStackTraceElement(bci).toString();
-                        AnalyzeMethodsRequiringMetadataUsageFeature.instance().addCall(methodType, methodName, callLocation);
+                        AnalyzeMethodsRequiringMetadataUsageFeature.instance().addCall(jarPath, methodType, methodName, callLocation);
                     }
                 }
             }