jruby-async-profiler 0.1.0

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

@@ -0,0 +1,55 @@
+/*
+ * 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.
+ */
+
+#ifndef _LOCKTRACER_H
+#define _LOCKTRACER_H
+
+#include <jvmti.h>
+#include "engine.h"
+
+
+typedef void (JNICALL *UnsafeParkFunc)(JNIEnv*, jobject, jboolean, jlong);
+
+class LockTracer : public Engine {
+  private:
+    static jlong _start_time;
+    static jclass _LockSupport;
+    static jmethodID _getBlocker;
+    static UnsafeParkFunc _original_Unsafe_Park;
+    static bool _supports_lock_names;
+
+    static jclass getParkBlockerClass(jvmtiEnv* jvmti, JNIEnv* env);
+    static void recordContendedLock(jclass lock_class, jlong time);
+    static void bindUnsafePark(UnsafeParkFunc entry);
+
+  public:
+    const char* name() {
+        return "lock";
+    }
+
+    const char* units() {
+        return "ns";
+    }
+
+    Error start(Arguments& args);
+    void stop();
+
+    static void JNICALL MonitorContendedEnter(jvmtiEnv* jvmti, JNIEnv* env, jthread thread, jobject object);
+    static void JNICALL MonitorContendedEntered(jvmtiEnv* jvmti, JNIEnv* env, jthread thread, jobject object);
+    static void JNICALL UnsafeParkTrap(JNIEnv* env, jobject instance, jboolean isAbsolute, jlong time);
+};
+
+#endif // _LOCKTRACER_H

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

@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#include "mutex.h"
+
+
+Mutex::Mutex() {
+    pthread_mutexattr_t attr;
+    pthread_mutexattr_init(&attr);
+    pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
+    pthread_mutex_init(&_mutex, &attr);
+}
+
+void Mutex::lock() {
+    pthread_mutex_lock(&_mutex);
+}
+
+void Mutex::unlock() {
+    pthread_mutex_unlock(&_mutex);
+}

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

@@ -0,0 +1,49 @@
+/*
+ * 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.
+ */
+
+#ifndef _MUTEX_H
+#define _MUTEX_H
+
+#include <pthread.h>
+
+
+class Mutex {
+  private:
+    pthread_mutex_t _mutex;
+
+  public:
+    Mutex();
+
+    void lock();
+    void unlock();
+};
+
+
+class MutexLocker {
+  private:
+    Mutex* _mutex;
+
+  public:
+    MutexLocker(Mutex& mutex) : _mutex(&mutex) {
+        _mutex->lock();
+    }
+
+    ~MutexLocker() {
+        _mutex->unlock();
+    }
+};
+
+#endif // _MUTEX_H

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

@@ -0,0 +1,45 @@
+/*
+ * 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.
+ */
+
+#ifndef _OS_H
+#define _OS_H
+
+#include <signal.h>
+#include "arch.h"
+
+
+class ThreadList {
+  public:
+    virtual ~ThreadList() {}
+    virtual int next() = 0;
+};
+
+
+class OS {
+  public:
+    static u64 nanotime();
+    static u64 millis();
+    static u64 hton64(u64 x);
+    static int threadId();
+    static bool isThreadRunning(int thread_id);
+    static bool isSignalSafeTLS();
+    static bool isJavaLibraryVisible();
+    static void installSignalHandler(int signo, void (*handler)(int, siginfo_t*, void*));
+    static void sendSignalToThread(int thread_id, int signo);
+    static ThreadList* listThreads();
+};
+
+#endif // _OS_H

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

@@ -0,0 +1,129 @@
+/*
+ * 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.
+ */
+
+#ifdef __linux__
+
+#include <arpa/inet.h>
+#include <byteswap.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/syscall.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+#include "os.h"
+
+
+class LinuxThreadList : public ThreadList {
+  private:
+    DIR* _dir;
+
+  public:
+    LinuxThreadList() {
+        _dir = opendir("/proc/self/task");
+    }
+
+    ~LinuxThreadList() {
+        if (_dir != NULL) {
+            closedir(_dir);
+        }
+    }
+
+    int next() {
+        if (_dir != NULL) {
+            struct dirent* entry;
+            while ((entry = readdir(_dir)) != NULL) {
+                if (entry->d_name[0] != '.') {
+                    return atoi(entry->d_name);
+                }
+            }
+        }
+        return -1;
+    }
+};
+
+
+u64 OS::nanotime() {
+    struct timespec tp;
+    clock_gettime(CLOCK_MONOTONIC, &tp);
+    return (u64)tp.tv_sec * 1000000000 + tp.tv_nsec;
+}
+
+u64 OS::millis() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (u64)tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+
+u64 OS::hton64(u64 x) {
+    return htonl(1) == 1 ? x : bswap_64(x);
+}
+
+int OS::threadId() {
+    return syscall(__NR_gettid);
+}
+
+bool OS::isThreadRunning(int thread_id) {
+    char buf[512];
+    sprintf(buf, "/proc/self/task/%d/stat", thread_id);
+    int fd = open(buf, O_RDONLY);
+    if (fd == -1) {
+        return false;
+    }
+
+    bool running = false;
+    if (read(fd, buf, sizeof(buf)) > 0) {
+        char* s = strchr(buf, ')');
+        running = s != NULL && (s[2] == 'R' || s[2] == 'D');
+    }
+
+    close(fd);
+    return running;
+}
+
+bool OS::isSignalSafeTLS() {
+    return true;
+}
+
+bool OS::isJavaLibraryVisible() {
+    return false;
+}
+
+void OS::installSignalHandler(int signo, void (*handler)(int, siginfo_t*, void*)) {
+    struct sigaction sa;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_sigaction = handler;
+    sa.sa_flags = SA_RESTART | SA_SIGINFO;
+
+    sigaction(signo, &sa, NULL);
+}
+
+void OS::sendSignalToThread(int thread_id, int signo) {
+    static const int self_pid = getpid();
+
+    syscall(__NR_tgkill, self_pid, thread_id, signo);
+}
+
+ThreadList* OS::listThreads() {
+    return new LinuxThreadList();
+}
+
+#endif // __linux__

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

@@ -0,0 +1,115 @@
+/*
+ * 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.
+ */
+
+#ifdef __APPLE__
+
+#include <libkern/OSByteOrder.h>
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <sys/time.h>
+#include "os.h"
+
+
+class MacThreadList : public ThreadList {
+  private:
+    thread_array_t _thread_array;
+    unsigned int _thread_count;
+    unsigned int _thread_index;
+
+  public:
+    MacThreadList() : _thread_array(NULL), _thread_count(0), _thread_index(0) {
+        task_threads(mach_task_self(), &_thread_array, &_thread_count);
+    }
+
+    ~MacThreadList() {
+        task_t task = mach_task_self();
+        for (int i = 0; i < _thread_count; i++) {
+            mach_port_deallocate(task, _thread_array[i]);
+        }
+        vm_deallocate(task, (vm_address_t)_thread_array, sizeof(thread_t) * _thread_count);
+    }
+
+    int next() {
+        if (_thread_index < _thread_count) {
+            return (int)_thread_array[_thread_index++];
+        }
+        return -1;
+    }
+};
+
+
+static mach_timebase_info_data_t timebase = {0, 0};
+
+u64 OS::nanotime() {
+    if (timebase.denom == 0) {
+        mach_timebase_info(&timebase);
+    }
+    return (u64)mach_absolute_time() * timebase.numer / timebase.denom;
+}
+
+u64 OS::millis() {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return (u64)tv.tv_sec * 1000 + tv.tv_usec / 1000;
+}
+
+u64 OS::hton64(u64 x) {
+    return OSSwapHostToBigInt64(x);
+}
+
+int OS::threadId() {
+    // Used to be pthread_mach_thread_np(pthread_self()),
+    // but pthread_mach_thread_np is not async signal safe
+    mach_port_t port = mach_thread_self();
+    mach_port_deallocate(mach_task_self(), port);
+    return (int)port;
+}
+
+bool OS::isThreadRunning(int thread_id) {
+    struct thread_basic_info info;
+    mach_msg_type_number_t size = sizeof(info);
+    if (thread_info((thread_act_t)thread_id, THREAD_BASIC_INFO, (thread_info_t)&info, &size) != 0) {
+        return false;
+    }
+    return info.run_state == TH_STATE_RUNNING;
+}
+
+bool OS::isSignalSafeTLS() {
+    return false;
+}
+
+bool OS::isJavaLibraryVisible() {
+    return true;
+}
+
+void OS::installSignalHandler(int signo, void (*handler)(int, siginfo_t*, void*)) {
+    struct sigaction sa;
+    sigemptyset(&sa.sa_mask);
+    sa.sa_sigaction = handler;
+    sa.sa_flags = SA_RESTART | SA_SIGINFO;
+
+    sigaction(signo, &sa, NULL);
+}
+
+void OS::sendSignalToThread(int thread_id, int signo) {
+   asm volatile("syscall" : : "a"(0x2000148), "D"(thread_id), "S"(signo));
+}
+
+ThreadList* OS::listThreads() {
+    return new MacThreadList();
+}
+
+#endif // __APPLE__

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

@@ -0,0 +1,60 @@
+/*
+ * 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.
+ */
+
+#ifndef _PERFEVENTS_H
+#define _PERFEVENTS_H
+
+#include <signal.h>
+#include "engine.h"
+
+
+class PerfEvent;
+class PerfEventType;
+
+class PerfEvents : public Engine {
+  private:
+    static int _max_events;
+    static PerfEvent* _events;
+    static PerfEventType* _event_type;
+    static long _interval;
+    static Ring _ring;
+    static bool _print_extended_warning;
+
+    static bool createForThread(int tid);
+    static void destroyForThread(int tid);
+    static void signalHandler(int signo, siginfo_t* siginfo, void* ucontext);
+
+  public:
+    const char* name() {
+        return "perf";
+    }
+
+    const char* units();
+
+    Error start(Arguments& args);
+    void stop();
+
+    void onThreadStart();
+    void onThreadEnd();
+
+    int getNativeTrace(void* ucontext, int tid, const void** callchain, int max_depth,
+                       const void* jit_min_address, const void* jit_max_address);
+
+    static bool supported();
+    static const char* getEventName(int event_id);
+};
+
+#endif // _PERFEVENTS_H