Merge branch 'unfold-inlining-info'

Author: jrudolph

AttachOnce.java

@@ -29,7 +29,7 @@ public class AttachOnce {
     public static void main(String[] args) throws Exception {
         String pid = args[0];
         String options = "";
-        if (args.length > 2) options = args[1];
+        if (args.length > 1) options = args[1];
         loadAgent(pid, options);
     }
 

README.md

@@ -17,10 +17,17 @@ Note: If `perf top` still doesn't show any detailled info it's probably because
 to run the java program as a regular user with the agent enabled and then run a `chown root /tmp/perf-<pid>.map` to make
 the file accessible for the root user. Then run `perf top` as root. The `perf-java` script tries to do that.
 
+## Options
+
+You can add a comma separated list of options to `perf-java` (or the `AttachOnce` runner). These options are currently supported:
+
+ - `unfold`: create extra entries for every codeblock inside a method that was inlined from elsewhere (named &lt;inlined_method&gt; in &lt;root_method&gt;)
+
 ## Disclaimer
 
 I'm not a professional C code writer. The code is very "experimental", and it is e.g. missing checks for error conditions etc.. Use it at your own risk. You have been warned!
 
 ## License
 
 This library is licensed under GPLv2. See the LICENSE file.
+

perf-java

@@ -1,10 +1,10 @@
 PID=$1
-PERF_MODE=$2
+OPTIONS=$2
 
 if [ -p $JAVA_HOME ]; then
   JAVA_HOME=/usr/lib/jvm/default-java
 fi
 
-java -cp attach-main.jar:$JAVA_HOME/lib/tools.jar net.virtualvoid.perf.AttachOnce $PID
+java -cp attach-main.jar:$JAVA_HOME/lib/tools.jar net.virtualvoid.perf.AttachOnce $PID $OPTIONS
 sudo chown root:root /tmp/perf-$PID.map
-sudo perf $PERF_MODE -p $PID
+sudo perf top -p $PID

perf-map-agent.c

@@ -19,52 +19,123 @@
  */
 
 #include <stdio.h>
+#include <string.h>
 
 #include <sys/types.h>
 
 #include <jni.h>
 #include <jvmti.h>
-#include <string.h>
+#include <jvmticmlr.h>
 
 #include "perf-map-file.h"
 
 FILE *method_file = NULL;
+int unfold_inlined_methods = 0;
 
 void ensure_open() {
     if (!method_file)
         method_file = perf_map_open(getpid());
 }
 
-static void JNICALL
-cbCompiledMethodLoad(jvmtiEnv *env,
-            jmethodID method,
-            jint code_size,
-            const void* code_addr,
-            jint map_length,
-            const jvmtiAddrLocationMap* map,
-            const void* compile_info) {
+static int get_line_number(jvmtiLineNumberEntry *table, jint entry_count, jlocation loc) {
+  int i;
+  for (i = 0; i < entry_count; i++)
+    if (table[i].start_location > loc) return table[i - 1].line_number;
+
+  return -1;
+}
+
+static void sig_string(jvmtiEnv *jvmti, jmethodID method, char *output, size_t noutput) {
     char *name;
     char *msig;
-    (*env)->GetMethodName(env, method, &name, &msig, NULL);
-
     jclass class;
-    (*env)->GetMethodDeclaringClass(env, method, &class);
     char *csig;
-    (*env)->GetClassSignature(env, class, &csig, NULL);
 
-    char entry[100];
-    snprintf(entry, sizeof(entry), "%s.%s%s", csig, name, msig);
+    (*jvmti)->GetMethodName(jvmti, method, &name, &msig, NULL);
+    (*jvmti)->GetMethodDeclaringClass(jvmti, method, &class);
+    (*jvmti)->GetClassSignature(jvmti, class, &csig, NULL);
 
-    ensure_open();
+    snprintf(output, noutput, "%s.%s%s", csig, name, msig);
+
+    (*jvmti)->Deallocate(jvmti, name);
+    (*jvmti)->Deallocate(jvmti, msig);
+    (*jvmti)->Deallocate(jvmti, csig);
+}
+
+void generate_single_entry(jvmtiEnv *jvmti, jmethodID method, const void *code_addr, jint code_size) {
+    char entry[100];
+    sig_string(jvmti, method, entry, sizeof(entry));
     perf_map_write_entry(method_file, code_addr, code_size, entry);
+}
 
-    (*env)->Deallocate(env, name);
-    (*env)->Deallocate(env, msig);
-    (*env)->Deallocate(env, csig);
+void generate_unfolded_entries(
+        jvmtiEnv *jvmti,
+        jmethodID method,
+        jint code_size,
+        const void* code_addr,
+        jint map_length,
+        const jvmtiAddrLocationMap* map,
+        const void* compile_info) {
+    int i;
+    const jvmtiCompiledMethodLoadRecordHeader *header = compile_info;
+    char root_name[1000];
+    char entry_name[1000];
+    char entry[1000];
+    sig_string(jvmti, method, root_name, sizeof(root_name));
+    if (header->kind == JVMTI_CMLR_INLINE_INFO) {
+        const char *entry_p;
+        const jvmtiCompiledMethodLoadInlineRecord *record = (jvmtiCompiledMethodLoadInlineRecord *) header;
+
+        const void *start_addr = code_addr;
+        jmethodID cur_method = method;
+        for (i = 0; i < record->numpcs; i++) {
+            PCStackInfo *info = &record->pcinfo[i];
+            jmethodID top_method = info->methods[0];
+            if (cur_method != top_method) {
+                void *end_addr = info->pc;
+
+                if (top_method != method) {
+                    sig_string(jvmti, top_method, entry_name, sizeof(entry_name));
+                    snprintf(entry, sizeof(entry), "%s in %s", entry_name, root_name);
+                    entry_p = entry;
+                } else
+                    entry_p = root_name;
+
+                perf_map_write_entry(method_file, start_addr, end_addr - start_addr, entry_p);
+
+                start_addr = info->pc;
+                cur_method = top_method;
+            }
+        }
+        if (start_addr != code_addr + code_size) {
+            const void *end_addr = code_addr + code_size;
+            sig_string(jvmti, cur_method, entry_name, sizeof(entry_name));
+            snprintf(entry, sizeof(entry), "%s in %s", entry_name, root_name);
+
+            perf_map_write_entry(method_file, start_addr, end_addr - start_addr, entry_p);
+        }
+    } else
+        generate_single_entry(jvmti, method, code_addr, code_size);
+}
+
+static void JNICALL
+cbCompiledMethodLoad(
+            jvmtiEnv *jvmti,
+            jmethodID method,
+            jint code_size,
+            const void* code_addr,
+            jint map_length,
+            const jvmtiAddrLocationMap* map,
+            const void* compile_info) {
+    ensure_open();
+    if (unfold_inlined_methods)
+        generate_unfolded_entries(jvmti, method, code_size, code_addr, map_length, map, compile_info); 
+    else
+        generate_single_entry(jvmti, method, code_addr, code_size);
 }
 
 void JNICALL
-cbDynamicCodeGenerated(jvmtiEnv *jvmti_env,
+cbDynamicCodeGenerated(jvmtiEnv *jvmti,
             const char* name,
             const void* address,
             jint length) {
@@ -109,6 +180,8 @@ Agent_OnAttach(JavaVM *vm, char *options, void *reserved) {
     ensure_open();
     ftruncate(fileno(method_file));
 
+    unfold_inlined_methods = strstr(options, "unfold") != NULL;
+
     jvmtiEnv *jvmti;
     (*vm)->GetEnv(vm, (void **)&jvmti, JVMTI_VERSION_1);
     enable_capabilities(jvmti);

perf-map-file.c

@@ -30,6 +30,6 @@ FILE *perf_map_open(pid_t pid) {
 }
 
 void perf_map_write_entry(FILE *method_file, const void* code_addr, unsigned int code_size, const char* entry) {
-    fprintf(method_file, "%lx %x %s\n", code_addr, code_size, entry);
+    fprintf(method_file, "%lx %x %s\n", (unsigned long) code_addr, code_size, entry);
     fflush(method_file);
 }