jruby-async-profiler 0.1.0

data/ext/async-profiler/src/symbols_macos.cpp

@@ -0,0 +1,156 @@
+/*
+ * Copyright 2017 Andrei Pangin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifdef __APPLE__
+
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <arpa/inet.h>
+#include <mach-o/dyld.h>
+#include <mach-o/loader.h>
+#include <mach-o/fat.h>
+#include <mach-o/nlist.h>
+#include "symbols.h"
+
+
+class MachOParser {
+  private:
+    NativeCodeCache* _cc;
+    const mach_header* _image_base;
+
+    static const char* add(const void* base, uint32_t offset) {
+        return (const char*)base + offset;
+    }
+
+    void loadSymbols(mach_header_64* header, symtab_command* symtab) {
+        nlist_64* symbol_table = (nlist_64*)add(header, symtab->symoff);
+        const char* str_table = add(header, symtab->stroff);
+
+        for (uint32_t i = 0; i < symtab->nsyms; i++) {
+            nlist_64 sym = symbol_table[i];
+            if ((sym.n_type & 0xee) == 0x0e && sym.n_value != 0) {
+                const char* addr = add(_image_base, sym.n_value);
+                const char* name = str_table + sym.n_un.n_strx;
+                if (name[0] == '_') name++;
+                _cc->add(addr, 0, name);
+            }
+        }
+    }
+
+    void parseMachO(mach_header_64* header) {
+        load_command* lc = (load_command*)(header + 1);
+
+        for (uint32_t i = 0; i < header->ncmds; i++) {
+            if (lc->cmd == LC_SYMTAB) {
+                loadSymbols(header, (symtab_command*)lc);
+                break;
+            }
+            lc = (load_command*)add(lc, lc->cmdsize);
+        }
+    }
+
+    void parseFatObject(fat_header* header) {
+        int narch = header->nfat_arch;
+        fat_arch* arch = (fat_arch*)(header + 1);
+
+        for (uint32_t i = 0; i < narch; i++) {
+            if (arch[i].cputype == _image_base->cputype &&
+                arch[i].cpusubtype == _image_base->cpusubtype) {
+                parseMachO((mach_header_64*)add(header, arch[i].offset));
+            }
+        }
+    }
+
+    // The same as parseFatObject, but fields are big-endian
+    void parseFatObjectBE(fat_header* header) {
+        int narch = htonl(header->nfat_arch);
+        fat_arch* arch = (fat_arch*)(header + 1);
+
+        for (uint32_t i = 0; i < narch; i++) {
+            if (htonl(arch[i].cputype) == _image_base->cputype &&
+                htonl(arch[i].cpusubtype) == _image_base->cpusubtype) {
+                parseMachO((mach_header_64*)add(header, htonl(arch[i].offset)));
+            }
+        }
+    }
+
+    void parse(mach_header* header) {
+        uint32_t magic = header->magic;
+        if (magic == MH_MAGIC_64) {
+            parseMachO((mach_header_64*)header);
+        } else if (magic == FAT_MAGIC) {
+            parseFatObject((fat_header*)header);
+        } else if (magic == FAT_CIGAM) {
+            parseFatObjectBE((fat_header*)header);
+        }
+    }
+
+  public:
+    MachOParser(NativeCodeCache* cc, const mach_header* image_base) : _cc(cc), _image_base(image_base) {
+    }
+
+    static void parseFile(NativeCodeCache* cc, const mach_header* image_base, const char* file_name) {
+        int fd = open(file_name, O_RDONLY);
+        if (fd == -1) {
+            return;
+        }
+
+        size_t length = (size_t)lseek(fd, 0, SEEK_END);
+        void* addr = mmap(NULL, length, PROT_READ, MAP_PRIVATE, fd, 0);
+        close(fd);
+
+        if (addr == MAP_FAILED) {
+            fprintf(stderr, "Could not parse symbols from %s: %s\n", file_name, strerror(errno));
+        } else {
+            MachOParser parser(cc, image_base);
+            parser.parse((mach_header*)addr);
+            munmap(addr, length);
+        }
+    }
+};
+
+
+Mutex Symbols::_parse_lock;
+std::set<const void*> Symbols::_parsed_libraries;
+
+void Symbols::parseKernelSymbols(NativeCodeCache* cc) {
+}
+
+void Symbols::parseLibraries(NativeCodeCache** array, volatile int& count, int size) {
+    MutexLocker ml(_parse_lock);
+    uint32_t images = _dyld_image_count();
+
+    for (uint32_t i = 0; i < images && count < size; i++) {
+        const mach_header* image_base = _dyld_get_image_header(i);
+        if (!_parsed_libraries.insert(image_base).second) {
+            continue;  // the library was already parsed
+        }
+
+        const char* path = _dyld_get_image_name(i);
+
+        NativeCodeCache* cc = new NativeCodeCache(path);
+        MachOParser::parseFile(cc, image_base, path);
+
+        cc->sort();
+        array[count] = cc;
+        atomicInc(count);
+    }
+}
+
+#endif // __APPLE__

data/ext/async-profiler/src/vmEntry.cpp

@@ -0,0 +1,173 @@
+/*
+ * Copyright 2016 Andrei Pangin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <fstream>
+#include <dlfcn.h>
+#include <string.h>
+#include "vmEntry.h"
+#include "arguments.h"
+#include "os.h"
+#include "profiler.h"
+#include "lockTracer.h"
+
+
+static Arguments _agent_args;
+
+JavaVM* VM::_vm;
+jvmtiEnv* VM::_jvmti = NULL;
+bool VM::_hotspot;
+void* VM::_libjvm;
+void* VM::_libjava;
+AsyncGetCallTrace VM::_asyncGetCallTrace;
+
+
+void VM::init(JavaVM* vm, bool attach) {
+    if (_jvmti != NULL) return;
+
+    _vm = vm;
+    _vm->GetEnv((void**)&_jvmti, JVMTI_VERSION_1_0);
+
+    char* vm_name;
+    if (_jvmti->GetSystemProperty("java.vm.name", &vm_name) == 0) {
+        _hotspot = strstr(vm_name, "Zing") == NULL;
+        _jvmti->Deallocate((unsigned char*)vm_name);
+    } else {
+        _hotspot = false;
+    }
+
+    jvmtiCapabilities capabilities = {0};
+    capabilities.can_generate_all_class_hook_events = 1;
+    capabilities.can_get_bytecodes = 1;
+    capabilities.can_get_constant_pool = 1;
+    capabilities.can_get_source_file_name = 1;
+    capabilities.can_get_line_numbers = 1;
+    capabilities.can_generate_compiled_method_load_events = 1;
+    capabilities.can_generate_monitor_events = 1;
+    capabilities.can_tag_objects = 1;
+    _jvmti->AddCapabilities(&capabilities);
+
+    jvmtiEventCallbacks callbacks = {0};
+    callbacks.VMInit = VMInit;
+    callbacks.VMDeath = VMDeath;
+    callbacks.ClassLoad = ClassLoad;
+    callbacks.ClassPrepare = ClassPrepare;
+    callbacks.CompiledMethodLoad = Profiler::CompiledMethodLoad;
+    callbacks.CompiledMethodUnload = Profiler::CompiledMethodUnload;
+    callbacks.DynamicCodeGenerated = Profiler::DynamicCodeGenerated;
+    callbacks.ThreadStart = Profiler::ThreadStart;
+    callbacks.ThreadEnd = Profiler::ThreadEnd;
+    callbacks.MonitorContendedEnter = LockTracer::MonitorContendedEnter;
+    callbacks.MonitorContendedEntered = LockTracer::MonitorContendedEntered;
+    _jvmti->SetEventCallbacks(&callbacks, sizeof(callbacks));
+
+    _jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, NULL);
+    _jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, NULL);
+    _jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_CLASS_LOAD, NULL);
+    _jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_CLASS_PREPARE, NULL);
+    _jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_COMPILED_METHOD_LOAD, NULL);
+    _jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_COMPILED_METHOD_UNLOAD, NULL);
+    _jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_DYNAMIC_CODE_GENERATED, NULL);
+
+    _libjvm = getLibraryHandle("libjvm.so");
+    _libjava = getLibraryHandle("libjava.so");
+    _asyncGetCallTrace = (AsyncGetCallTrace)dlsym(_libjvm, "AsyncGetCallTrace");
+
+    if (attach) {
+        loadAllMethodIDs(_jvmti);
+        _jvmti->GenerateEvents(JVMTI_EVENT_DYNAMIC_CODE_GENERATED);
+        _jvmti->GenerateEvents(JVMTI_EVENT_COMPILED_METHOD_LOAD);
+    }
+}
+
+void* VM::getLibraryHandle(const char* name) {
+    if (!OS::isJavaLibraryVisible()) {
+        void* handle = dlopen(name, RTLD_LAZY);
+        if (handle != NULL) {
+            return handle;
+        }
+        std::cerr << "Failed to load " << name << ": " << dlerror() << std::endl;
+    }
+    return RTLD_DEFAULT;
+}
+
+void VM::loadMethodIDs(jvmtiEnv* jvmti, jclass klass) {
+    jint method_count;
+    jmethodID* methods;
+    if (jvmti->GetClassMethods(klass, &method_count, &methods) == 0) {
+        jvmti->Deallocate((unsigned char*)methods);
+    }
+}
+
+void VM::loadAllMethodIDs(jvmtiEnv* jvmti) {
+    jint class_count;
+    jclass* classes;
+    if (jvmti->GetLoadedClasses(&class_count, &classes) == 0) {
+        for (int i = 0; i < class_count; i++) {
+            loadMethodIDs(jvmti, classes[i]);
+        }
+        jvmti->Deallocate((unsigned char*)classes);
+    }
+}
+
+void JNICALL VM::VMInit(jvmtiEnv* jvmti, JNIEnv* jni, jthread thread) {
+    loadAllMethodIDs(jvmti);
+    // Delayed start of profiler if agent has been loaded at VM bootstrap
+    Profiler::_instance.run(_agent_args);
+}
+
+void JNICALL VM::VMDeath(jvmtiEnv* jvmti, JNIEnv* jni) {
+    Profiler::_instance.shutdown(_agent_args);
+}
+
+
+extern "C" JNIEXPORT jint JNICALL
+Agent_OnLoad(JavaVM* vm, char* options, void* reserved) {
+    VM::init(vm, false);
+
+    Error error = _agent_args.parse(options);
+    if (error) {
+        std::cerr << error.message() << std::endl;
+        return -1;
+    }
+
+    return 0;
+}
+
+extern "C" JNIEXPORT jint JNICALL
+Agent_OnAttach(JavaVM* vm, char* options, void* reserved) {
+    VM::init(vm, true);
+
+    Arguments args;
+    Error error = args.parse(options);
+    if (error) {
+        std::cerr << error.message() << std::endl;
+        return -1;
+    }
+
+    // Save the arguments in case of shutdown
+    if (args._action == ACTION_START || args._action == ACTION_RESUME) {
+        _agent_args.save(args);
+    }
+    Profiler::_instance.run(args);
+
+    return 0;
+}
+
+extern "C" JNIEXPORT jint JNICALL
+JNI_OnLoad(JavaVM* vm, void* reserved) {
+    VM::init(vm, true);
+    return JNI_VERSION_1_6;
+}

data/ext/async-profiler/src/vmEntry.h

@@ -0,0 +1,105 @@
+/*
+ * Copyright 2016 Andrei Pangin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _VMENTRY_H
+#define _VMENTRY_H
+
+#include <jvmti.h>
+
+
+// Denotes ASGCT_CallFrame where method_id has special meaning (not jmethodID)
+enum ASGCT_CallFrameType {
+    BCI_NATIVE_FRAME        = -10,  // method_id is native function name (char*)
+    BCI_SYMBOL              = -11,  // method_id is VMSymbol*
+    BCI_SYMBOL_OUTSIDE_TLAB = -12,  // VMSymbol* specifically for allocations outside TLAB
+    BCI_THREAD_ID           = -13,  // method_id designates a thread
+    BCI_ERROR               = -14,  // method_id is error string
+};
+
+// See hotspot/src/share/vm/prims/forte.cpp
+enum ASGCT_Failure {
+    ticks_no_Java_frame         =  0,
+    ticks_no_class_load         = -1,
+    ticks_GC_active             = -2,
+    ticks_unknown_not_Java      = -3,
+    ticks_not_walkable_not_Java = -4,
+    ticks_unknown_Java          = -5,
+    ticks_not_walkable_Java     = -6,
+    ticks_unknown_state         = -7,
+    ticks_thread_exit           = -8,
+    ticks_deopt                 = -9,
+    ticks_safepoint             = -10,
+    ticks_skipped               = -11,
+    ASGCT_FAILURE_TYPES         = 12
+};
+
+typedef struct {
+    jint bci;
+    jmethodID method_id;
+} ASGCT_CallFrame;
+
+typedef struct {
+    JNIEnv* env;
+    jint num_frames;
+    ASGCT_CallFrame* frames;
+} ASGCT_CallTrace;
+
+typedef void (*AsyncGetCallTrace)(ASGCT_CallTrace*, jint, void*);
+
+
+class VM {
+  private:
+    static JavaVM* _vm;
+    static jvmtiEnv* _jvmti;
+    static bool _hotspot;
+
+    static void* getLibraryHandle(const char* name);
+    static void loadMethodIDs(jvmtiEnv* jvmti, jclass klass);
+    static void loadAllMethodIDs(jvmtiEnv* jvmti);
+
+  public:
+    static void* _libjvm;
+    static void* _libjava;
+    static AsyncGetCallTrace _asyncGetCallTrace;
+
+    static void init(JavaVM* vm, bool attach);
+
+    static jvmtiEnv* jvmti() {
+        return _jvmti;
+    }
+
+    static JNIEnv* jni() {
+        JNIEnv* jni;
+        return _vm->GetEnv((void**)&jni, JNI_VERSION_1_6) == 0 ? jni : NULL;
+    }
+
+    static bool is_hotspot() {
+        return _hotspot;
+    }
+
+    static void JNICALL VMInit(jvmtiEnv* jvmti, JNIEnv* jni, jthread thread);
+    static void JNICALL VMDeath(jvmtiEnv* jvmti, JNIEnv* jni);
+
+    static void JNICALL ClassLoad(jvmtiEnv* jvmti, JNIEnv* jni, jthread thread, jclass klass) {
+        // Needed only for AsyncGetCallTrace support
+    }
+
+    static void JNICALL ClassPrepare(jvmtiEnv* jvmti, JNIEnv* jni, jthread thread, jclass klass) {
+        loadMethodIDs(jvmti, klass);
+    }
+};
+
+#endif // _VMENTRY_H

data/ext/async-profiler/src/vmStructs.cpp

@@ -0,0 +1,104 @@
+/*
+ * Copyright 2017 Andrei Pangin
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdint.h>
+#include <string.h>
+#include "vmStructs.h"
+#include "vmEntry.h"
+
+
+int VMStructs::_klass_name_offset = -1;
+int VMStructs::_symbol_length_offset = -1;
+int VMStructs::_symbol_length_and_refcount_offset = -1;
+int VMStructs::_symbol_body_offset = -1;
+int VMStructs::_class_klass_offset = -1;
+int VMStructs::_thread_osthread_offset = -1;
+int VMStructs::_osthread_id_offset = -1;
+bool VMStructs::_has_perm_gen = false;
+jfieldID VMStructs::_eetop = NULL;
+
+static uintptr_t readSymbol(NativeCodeCache* lib, const char* symbol_name) {
+    const void* symbol = lib->findSymbol(symbol_name);
+    if (symbol == NULL) {
+        // Avoid JVM crash in case of missing symbols
+        return 0;
+    }
+    return *(uintptr_t*)symbol;
+}
+
+void VMStructs::init(NativeCodeCache* libjvm) {
+    if (available()) {
+        return;
+    }
+
+    uintptr_t entry = readSymbol(libjvm, "gHotSpotVMStructs");
+    uintptr_t stride = readSymbol(libjvm, "gHotSpotVMStructEntryArrayStride");
+    uintptr_t type_offset = readSymbol(libjvm, "gHotSpotVMStructEntryTypeNameOffset");
+    uintptr_t field_offset = readSymbol(libjvm, "gHotSpotVMStructEntryFieldNameOffset");
+    uintptr_t offset_offset = readSymbol(libjvm, "gHotSpotVMStructEntryOffsetOffset");
+    uintptr_t address_offset = readSymbol(libjvm, "gHotSpotVMStructEntryAddressOffset");
+
+    if (entry == 0 || stride == 0) {
+        return;
+    }
+
+    while (true) {
+        const char* type = *(const char**)(entry + type_offset);
+        const char* field = *(const char**)(entry + field_offset);
+        if (type == NULL || field == NULL) {
+            break;
+        }
+
+        if (strcmp(type, "Klass") == 0) {
+            if (strcmp(field, "_name") == 0) {
+                _klass_name_offset = *(int*)(entry + offset_offset);
+            }
+        } else if (strcmp(type, "Symbol") == 0) {
+            if (strcmp(field, "_length") == 0) {
+                _symbol_length_offset = *(int*)(entry + offset_offset);
+            } else if (strcmp(field, "_length_and_refcount") == 0) {
+                _symbol_length_and_refcount_offset = *(int*)(entry + offset_offset);
+            } else if (strcmp(field, "_body") == 0) {
+                _symbol_body_offset = *(int*)(entry + offset_offset);
+            }
+        } else if (strcmp(type, "java_lang_Class") == 0) {
+            if (strcmp(field, "_klass_offset") == 0) {
+                _class_klass_offset = **(int**)(entry + address_offset);
+            }
+        } else if (strcmp(type, "JavaThread") == 0) {
+            if (strcmp(field, "_osthread") == 0) {
+                _thread_osthread_offset = *(int*)(entry + offset_offset);
+            }
+        } else if (strcmp(type, "OSThread") == 0) {
+            if (strcmp(field, "_thread_id") == 0) {
+                _osthread_id_offset = *(int*)(entry + offset_offset);
+            }
+        } else if (strcmp(type, "PermGen") == 0) {
+            _has_perm_gen = true;
+        }
+
+        entry += stride;
+    }
+
+    // Get eetop field - a bridge from Java Thread to VMThread
+    if (_thread_osthread_offset >= 0 && _osthread_id_offset >= 0) {
+        JNIEnv* env = VM::jni();
+        jclass threadClass = env->FindClass("java/lang/Thread");
+        if (threadClass != NULL) {
+            _eetop = env->GetFieldID(threadClass, "eetop", "J");
+        }
+    }
+}