async-profiler#1174: Add handling for JVM being created on a different thread than the async-profiler

Author: Baraa-Hasheesh

Makefile

@@ -210,7 +210,7 @@ build-test-bins:
 	@mkdir -p $(TEST_BIN_DIR)
 	gcc -o $(TEST_BIN_DIR)/malloc_plt_dyn test/test/nativemem/malloc_plt_dyn.c
 	gcc -o $(TEST_BIN_DIR)/native_api -Isrc test/test/c/native_api.c -ldl
-	$(CXX) -o $(TEST_BIN_DIR)/non_java_app $(CPP_TEST_INCLUDES) $(INCLUDES) test/test/nonjava/non_java_app.cpp -ldl
+	$(CXX) -o $(TEST_BIN_DIR)/non_java_app $(CPP_TEST_INCLUDES) $(INCLUDES) test/test/nonjava/non_java_app.cpp -ldl -pthread
 
 test-cpp: build-test-cpp
 	echo "Running cpp tests..."

src/vmEntry.cpp

@@ -106,6 +106,43 @@ static void* resolveMethodIdEnd() {
     return NULL;
 }
 
+void VM::initWrapper(JavaVM* vm) {
+    JNIEnv* env;
+
+    jint get_env_result = vm->GetEnv((void**)&env, JNI_VERSION_1_6);
+    if (get_env_result == JNI_OK) {
+        VM::init(vm, true);
+        return;
+    } else if (get_env_result != JNI_EDETACHED) {
+        return;
+    }
+
+    // VM exists but not attached to current thread    
+
+    // Work around for JDK-8308341, as JNI might return a none initialized VM so we check for the existence of certain VM threads 
+    // "VM Thread" and "Service Thread" in this case are used as indication that the VM is in a good enough state to be used
+    char thread_name[4096];
+    bool vm_thread = false, service_thread = false;
+
+    ThreadList* list = OS::listThreads();
+    while (list->hasNext()) {
+        if (!OS::threadName(list->next(), thread_name, 4096)) {
+            continue;
+        }
+
+        if (thread_name[0] == 'V' && strcmp(thread_name, "VM Thread") == 0) {
+            vm_thread = true;
+        } else if (thread_name[0] == 'S' && strcmp(thread_name, "Service Thread") == 0) {
+            service_thread = true;
+        }
+    }
+
+    // Check that VM is in a good state to attach the thread
+    if (service_thread && vm_thread && vm->AttachCurrentThreadAsDaemon((void**)&env, NULL) == JNI_OK) {
+        VM::init(vm, true);
+        return;
+    }
+}
 
 bool VM::init(JavaVM* vm, bool attach) {
     if (_jvmti != NULL) return true;
@@ -487,5 +524,5 @@ void VM::tryAttach() {
     if (result != JNI_OK || nVMs != 1) {
         return;
     }
-    VM::init(jvm, true);
+    VM::initWrapper(jvm);
 }

src/vmEntry.h

@@ -113,6 +113,8 @@ class VM {
     static void loadMethodIDs(jvmtiEnv* jvmti, JNIEnv* jni, jclass klass);
     static void loadAllMethodIDs(jvmtiEnv* jvmti, JNIEnv* jni);
 
+    static void initWrapper(JavaVM* vm);
+
   public:
     static AsyncGetCallTrace _asyncGetCallTrace;
     static JVM_MemoryFunc _totalMemory;

test/test/nonjava/NonjavaTests.java

@@ -43,4 +43,14 @@ public void jvmInBetweenTest(TestProcess p) throws Exception {
         out = p.readFile("%s");
         assert out.contains(".cpuHeavyTask");
     }
+
+    // jvm is loaded before the profiling session is started on a different thread
+    @Test(sh = "%testbin/non_java_app 4 %s.html", output = true)
+    public void differentThread(TestProcess p) throws Exception {
+        Output out = p.waitForExit(TestProcess.STDOUT);
+        assert p.exitCode() == 0;
+
+        out = p.readFile("%s");
+        assert out.contains(".cpuHeavyTask");
+    }
 }

test/test/nonjava/non_java_app.cpp

@@ -9,6 +9,7 @@
 #include <iostream>
 #include <limits.h>
 #include "asprof.h"
+#include <pthread.h>
 
 // detect arch for java 8
 #if defined(__x86_64__) || defined(_M_X64)
@@ -266,7 +267,7 @@ The JVM is started after the profiling session is started so it's not attached c
 However the second profiling session is started after the JVM is started so it's attached correctly at the session start
 */
 void testFlow3(int argc, char** argv) {
-    validateArgsCount(argc, 4, "Test requires 4 arguments");
+    validateArgsCount(argc, 4, "Test requires 3 arguments");
 
     loadProfiler();
 
@@ -289,8 +290,53 @@ void testFlow3(int argc, char** argv) {
     stopJvm();
 }
 
+void* jvmThreadWrapper(void* arg) {
+    loadJvmLib();
+
+    startJvm();
+
+    while(1) executeJvmTask();
+
+    return NULL;
+}
+
+/*
+Here is the flow of the test:
+1. Load the profiler
+2. Load the JVM library
+3. Start the JVM on  a different thread
+4. Start the profiler
+5. Execute the JVM task
+6. Stop the profiler
+7. Stop the JVM
+
+Expected output:
+The profiler should be able to profile the JVM task
+
+Explaination:
+The JVM is loaded and started before the profiling session is started so it's attached correctly at the session start
+*/
+void testFlow4(int argc, char** argv) {
+    validateArgsCount(argc, 3, "Minimum Arguments is 2");
+
+    loadProfiler();
+
+    pthread_t thread;
+    pthread_create(&thread, NULL, jvmThreadWrapper, NULL);
+   
+    // busy wait for JVM to start on the thread
+    for (int i = 0; i < 10; i++) for (int i = 0; i < 1000000000; ++i) {}
+
+    startProfiler();
+
+    // busy wait for profiler to sample JVM
+    for (int i = 0; i < 10; i++) for (int i = 0; i < 1000000000; ++i) {}
+
+    stopProfiler(argv[2]);
+}
+
 int main(int argc, char** argv) {
-    validateArgsCount(argc, 3, "Minimum Arguments is 3");
+    validateArgsCount(argc, 3, "Minimum Arguments is 2");
 
     // Check which test to run
     char* flow = argv[1];
@@ -304,6 +350,9 @@ int main(int argc, char** argv) {
         case '3': 
             testFlow3(argc, argv);
             break;
+        case '4':
+            testFlow4(argc, argv);
+            break;
         default:
             std::cerr << "Unknown flow: " << flow[0] << std::endl;
             exit(1);