jruby-async-profiler 0.1.0

data/ext/async-profiler/src/java/one/profiler/AsyncProfiler.java

@@ -0,0 +1,160 @@
+/*
+ * Copyright 2018 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.
+ */
+
+package one.profiler;
+
+/**
+ * Java API for in-process profiling. Serves as a wrapper around
+ * async-profiler native library. This class is a singleton.
+ * The first call to {@link #getInstance()} initiates loading of
+ * libasyncProfiler.so.
+ */
+public class AsyncProfiler implements AsyncProfilerMXBean {
+    private static AsyncProfiler instance;
+
+    private final String version;
+
+    private AsyncProfiler() {
+        this.version = version0();
+    }
+
+    public static AsyncProfiler getInstance() {
+        return getInstance(null);
+    }
+
+    public static synchronized AsyncProfiler getInstance(String libPath) {
+        if (instance != null) {
+            return instance;
+        }
+
+        if (libPath == null) {
+            System.loadLibrary("asyncProfiler");
+        } else {
+            System.load(libPath);
+        }
+
+        instance = new AsyncProfiler();
+        return instance;
+    }
+
+    /**
+     * Start profiling
+     *
+     * @param event Profiling event, see {@link Events}
+     * @param interval Sampling interval, e.g. nanoseconds for Events.CPU
+     * @throws IllegalStateException If profiler is already running
+     */
+    @Override
+    public void start(String event, long interval) throws IllegalStateException {
+        start0(event, interval, true);
+    }
+
+    /**
+     * Start or resume profiling without resetting collected data.
+     * Note that event and interval may change since the previous profiling session.
+     *
+     * @param event Profiling event, see {@link Events}
+     * @param interval Sampling interval, e.g. nanoseconds for Events.CPU
+     * @throws IllegalStateException If profiler is already running
+     */
+    @Override
+    public void resume(String event, long interval) throws IllegalStateException {
+        start0(event, interval, false);
+    }
+
+    /**
+     * Stop profiling (without dumping results)
+     *
+     * @throws IllegalStateException If profiler is not running
+     */
+    @Override
+    public void stop() throws IllegalStateException {
+        stop0();
+    }
+
+    /**
+     * Get the number of samples collected during the profiling session
+     *
+     * @return Number of samples
+     */
+    @Override
+    public native long getSamples();
+
+    /**
+     * Get profiler agent version, e.g. "1.0"
+     *
+     * @return Version string
+     */
+    @Override
+    public String getVersion() {
+        return version;
+    }
+
+    /**
+     * Execute an agent-compatible profiling command -
+     * the comma-separated list of arguments described in arguments.cpp
+     *
+     * @param command Profiling command
+     * @return The command result
+     * @throws IllegalArgumentException If failed to parse the command
+     * @throws java.io.IOException If failed to create output file
+     */
+    @Override
+    public String execute(String command) throws IllegalArgumentException, java.io.IOException {
+        return execute0(command);
+    }
+
+    /**
+     * Dump profile in 'collapsed stacktraces' format
+     *
+     * @param counter Which counter to display in the output
+     * @return Textual representation of the profile
+     */
+    @Override
+    public String dumpCollapsed(Counter counter) {
+        return dumpCollapsed0(counter.ordinal());
+    }
+
+    /**
+     * Dump collected stack traces
+     *
+     * @param maxTraces Maximum number of stack traces to dump. 0 means no limit
+     * @return Textual representation of the profile
+     */
+    @Override
+    public String dumpTraces(int maxTraces) {
+        return dumpTraces0(maxTraces);
+    }
+
+    /**
+     * Dump flat profile, i.e. the histogram of the hottest methods
+     *
+     * @param maxMethods Maximum number of methods to dump. 0 means no limit
+     * @return Textual representation of the profile
+     */
+    @Override
+    public String dumpFlat(int maxMethods) {
+        return dumpFlat0(maxMethods);
+    }
+
+    private native void start0(String event, long interval, boolean reset) throws IllegalStateException;
+    private native void stop0() throws IllegalStateException;
+    private native String execute0(String command) throws IllegalArgumentException, java.io.IOException;
+    private native String dumpCollapsed0(int counter);
+    private native String dumpTraces0(int maxTraces);
+    private native String dumpFlat0(int maxMethods);
+    private native String version0();
+}

data/ext/async-profiler/src/java/one/profiler/AsyncProfilerMXBean.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2018 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.
+ */
+
+package one.profiler;
+
+/**
+ * AsyncProfiler interface for JMX server.
+ * How to register AsyncProfiler MBean:
+ *
+ * <pre>{@code
+ *     ManagementFactory.getPlatformMBeanServer().registerMBean(
+ *             AsyncProfiler.getInstance(),
+ *             new ObjectName("one.profiler:type=AsyncProfiler")
+ *     );
+ * }</pre>
+ */
+public interface AsyncProfilerMXBean {
+    void start(String event, long interval) throws IllegalStateException;
+    void resume(String event, long interval) throws IllegalStateException;
+    void stop() throws IllegalStateException;
+
+    long getSamples();
+    String getVersion();
+
+    String execute(String command) throws IllegalArgumentException, java.io.IOException;
+
+    String dumpCollapsed(Counter counter);
+    String dumpTraces(int maxTraces);
+    String dumpFlat(int maxMethods);
+}

data/ext/async-profiler/src/java/one/profiler/Counter.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2018 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.
+ */
+
+package one.profiler;
+
+/**
+ * Which metrics to use when generating profile in collapsed stack traces format.
+ */
+public enum Counter {
+    SAMPLES,
+    TOTAL
+}

data/ext/async-profiler/src/java/one/profiler/Events.java

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2018 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.
+ */
+
+package one.profiler;
+
+/**
+ * Predefined event names to use in {@link AsyncProfiler#start(String, long)}
+ */
+public class Events {
+    public static final String CPU    = "cpu";
+    public static final String ALLOC  = "alloc";
+    public static final String LOCK   = "lock";
+    public static final String WALL   = "wall";
+    public static final String ITIMER = "itimer";
+}

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

@@ -0,0 +1,124 @@
+/*
+ * 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 <sstream>
+#include <errno.h>
+#include <string.h>
+#include "arguments.h"
+#include "profiler.h"
+
+
+static void throw_new(JNIEnv* env, const char* exception_class, const char* message) {
+    jclass cls = env->FindClass(exception_class);
+    if (cls != NULL) {
+        env->ThrowNew(cls, message);
+    }
+}
+
+
+extern "C" JNIEXPORT void JNICALL
+Java_one_profiler_AsyncProfiler_start0(JNIEnv* env, jobject unused, jstring event, jlong interval, jboolean reset) {
+    Arguments args;
+    args._event = env->GetStringUTFChars(event, NULL);
+    args._interval = interval;
+    Error error = Profiler::_instance.start(args, reset);
+    env->ReleaseStringUTFChars(event, args._event);
+
+    if (error) {
+        throw_new(env, "java/lang/IllegalStateException", error.message());
+    }
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_one_profiler_AsyncProfiler_stop0(JNIEnv* env, jobject unused) {
+    Error error = Profiler::_instance.stop();
+
+    if (error) {
+        throw_new(env, "java/lang/IllegalStateException", error.message());
+    }
+}
+
+extern "C" JNIEXPORT jlong JNICALL
+Java_one_profiler_AsyncProfiler_getSamples(JNIEnv* env, jobject unused) {
+    return (jlong)Profiler::_instance.total_samples();
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_one_profiler_AsyncProfiler_execute0(JNIEnv* env, jobject unused, jstring command) {
+    Arguments args;
+    const char* command_str = env->GetStringUTFChars(command, NULL);
+    Error error = args.parse(command_str);
+    env->ReleaseStringUTFChars(command, command_str);
+
+    if (error) {
+        throw_new(env, "java/lang/IllegalArgumentException", error.message());
+        return NULL;
+    }
+
+    if (args._file == NULL || args._output == OUTPUT_JFR) {
+        std::ostringstream out;
+        Profiler::_instance.runInternal(args, out);
+        return env->NewStringUTF(out.str().c_str());
+    } else {
+        std::ofstream out(args._file, std::ios::out | std::ios::trunc);
+        if (out.is_open()) {
+            Profiler::_instance.runInternal(args, out);
+            out.close();
+            return env->NewStringUTF("OK");
+        } else {
+            throw_new(env, "java/io/IOException", strerror(errno));
+            return NULL;
+        }
+    }
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_one_profiler_AsyncProfiler_dumpCollapsed0(JNIEnv* env, jobject unused, jint counter) {
+    Arguments args;
+    args._counter = counter == COUNTER_SAMPLES ? COUNTER_SAMPLES : COUNTER_TOTAL;
+
+    std::ostringstream out;
+    Profiler::_instance.dumpCollapsed(out, args);
+    return env->NewStringUTF(out.str().c_str());
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_one_profiler_AsyncProfiler_dumpTraces0(JNIEnv* env, jobject unused, jint max_traces) {
+    Arguments args;
+    args._dump_traces = max_traces ? max_traces : MAX_CALLTRACES;
+
+    std::ostringstream out;
+    Profiler::_instance.dumpSummary(out);
+    Profiler::_instance.dumpTraces(out, args);
+    return env->NewStringUTF(out.str().c_str());
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_one_profiler_AsyncProfiler_dumpFlat0(JNIEnv* env, jobject unused, jint max_methods) {
+    Arguments args;
+    args._dump_flat = max_methods ? max_methods : MAX_CALLTRACES;
+
+    std::ostringstream out;
+    Profiler::_instance.dumpSummary(out);
+    Profiler::_instance.dumpFlat(out, args);
+    return env->NewStringUTF(out.str().c_str());
+}
+
+extern "C" JNIEXPORT jstring JNICALL
+Java_one_profiler_AsyncProfiler_version0(JNIEnv* env, jobject unused) {
+    return env->NewStringUTF(PROFILER_VERSION);
+}

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

@@ -0,0 +1,161 @@
+/*
+ * 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 <string.h>
+#include "lockTracer.h"
+#include "profiler.h"
+#include "vmStructs.h"
+
+
+jlong LockTracer::_start_time = 0;
+jclass LockTracer::_LockSupport = NULL;
+jmethodID LockTracer::_getBlocker = NULL;
+UnsafeParkFunc LockTracer::_original_Unsafe_Park = NULL;
+bool LockTracer::_supports_lock_names = false;
+
+Error LockTracer::start(Arguments& args) {
+    // PermGen in JDK 7 makes difficult to get symbol name from jclass.
+    // Also some JVMs do not support VMStructs at all.
+    // Let's just record stack traces without lock names in these cases.
+    _supports_lock_names = VMStructs::available() && !VMStructs::hasPermGen();
+
+    // Enable Java Monitor events
+    jvmtiEnv* jvmti = VM::jvmti();
+    jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_MONITOR_CONTENDED_ENTER, NULL);
+    jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, NULL);
+    jvmti->GetTime(&_start_time);
+
+    if (_getBlocker == NULL) {
+        JNIEnv* env = VM::jni();
+        _LockSupport = (jclass)env->NewGlobalRef(env->FindClass("java/util/concurrent/locks/LockSupport"));
+        _getBlocker = env->GetStaticMethodID(_LockSupport, "getBlocker", "(Ljava/lang/Thread;)Ljava/lang/Object;");
+    }
+
+    if (_original_Unsafe_Park == NULL) {
+        NativeCodeCache* libjvm = Profiler::_instance.jvmLibrary();
+        _original_Unsafe_Park = (UnsafeParkFunc)libjvm->findSymbol("Unsafe_Park");
+        if (_original_Unsafe_Park == NULL) {
+            // In some macOS builds of JDK 11 Unsafe_Park appears to have a C++ decorated name
+            _original_Unsafe_Park = (UnsafeParkFunc)libjvm->findSymbol("_ZL11Unsafe_ParkP7JNIEnv_P8_jobjecthl");
+        }
+    }
+
+    // Intercent Unsafe.park() for tracing contended ReentrantLocks
+    if (_original_Unsafe_Park != NULL) {
+        bindUnsafePark(UnsafeParkTrap);
+    }
+
+    return Error::OK;
+}
+
+void LockTracer::stop() {
+    // Disable Java Monitor events
+    jvmtiEnv* jvmti = VM::jvmti();
+    jvmti->SetEventNotificationMode(JVMTI_DISABLE, JVMTI_EVENT_MONITOR_CONTENDED_ENTER, NULL);
+    jvmti->SetEventNotificationMode(JVMTI_DISABLE, JVMTI_EVENT_MONITOR_CONTENDED_ENTERED, NULL);
+
+    // Reset Unsafe.park() trap
+    if (_original_Unsafe_Park != NULL) {
+        bindUnsafePark(_original_Unsafe_Park);
+    }
+}
+
+void JNICALL LockTracer::MonitorContendedEnter(jvmtiEnv* jvmti, JNIEnv* env, jthread thread, jobject object) {
+    jlong enter_time;
+    jvmti->GetTime(&enter_time);
+    jvmti->SetTag(thread, enter_time);
+}
+
+void JNICALL LockTracer::MonitorContendedEntered(jvmtiEnv* jvmti, JNIEnv* env, jthread thread, jobject object) {
+    jlong enter_time, entered_time;
+    jvmti->GetTime(&entered_time);
+    jvmti->GetTag(thread, &enter_time);
+
+    // Time is meaningless if lock attempt has started before profiling
+    if (enter_time >= _start_time) {
+        recordContendedLock(env->GetObjectClass(object), entered_time - enter_time);
+    }
+}
+
+void JNICALL LockTracer::UnsafeParkTrap(JNIEnv* env, jobject instance, jboolean isAbsolute, jlong time) {
+    jvmtiEnv* jvmti = VM::jvmti();
+    jclass lock_class = getParkBlockerClass(jvmti, env);
+    jlong park_start_time, park_end_time;
+
+    if (lock_class != NULL) {
+        jvmti->GetTime(&park_start_time);
+    }
+    
+    _original_Unsafe_Park(env, instance, isAbsolute, time);
+
+    if (lock_class != NULL) {
+        jvmti->GetTime(&park_end_time);
+        recordContendedLock(lock_class, park_end_time - park_start_time);
+    }
+}
+
+jclass LockTracer::getParkBlockerClass(jvmtiEnv* jvmti, JNIEnv* env) {
+    jthread thread;
+    if (jvmti->GetCurrentThread(&thread) != 0) {
+        return NULL;
+    }
+
+    // Call LockSupport.getBlocker(Thread.currentThread())
+    jobject park_blocker = env->CallStaticObjectMethod(_LockSupport, _getBlocker, thread);
+    if (park_blocker == NULL) {
+        return NULL;
+    }
+
+    jclass lock_class = env->GetObjectClass(park_blocker);
+    char* class_name;
+    if (jvmti->GetClassSignature(lock_class, &class_name, NULL) != 0) {
+        return NULL;
+    }
+
+    // Do not count synchronizers other than ReentrantLock, ReentrantReadWriteLock and Semaphore
+    if (strncmp(class_name, "Ljava/util/concurrent/locks/ReentrantLock", 41) != 0 &&
+        strncmp(class_name, "Ljava/util/concurrent/locks/ReentrantReadWriteLock", 50) != 0 &&
+        strncmp(class_name, "Ljava/util/concurrent/Semaphore", 31) != 0) {
+        lock_class = NULL;
+    }
+
+    jvmti->Deallocate((unsigned char*)class_name);
+    return lock_class;
+}
+
+void LockTracer::recordContendedLock(jclass lock_class, jlong time) {
+    if (_supports_lock_names) {
+        VMSymbol* lock_name = (*(java_lang_Class**)lock_class)->klass()->name();
+        Profiler::_instance.recordSample(NULL, time, BCI_SYMBOL, (jmethodID)lock_name);
+    } else {
+        Profiler::_instance.recordSample(NULL, time, BCI_SYMBOL, NULL);
+    }
+}
+
+void LockTracer::bindUnsafePark(UnsafeParkFunc entry) {
+    JNIEnv* env = VM::jni();
+
+    // Try JDK 9+ package first, then fallback to JDK 8 package
+    jclass unsafe = env->FindClass("jdk/internal/misc/Unsafe");
+    if (unsafe == NULL) unsafe = env->FindClass("sun/misc/Unsafe");
+
+    if (unsafe != NULL) {
+        const JNINativeMethod unsafe_park = {(char*)"park", (char*)"(ZJ)V", (void*)entry};
+        env->RegisterNatives(unsafe, &unsafe_park, 1);
+    }
+
+    env->ExceptionClear();
+}