jruby-async-profiler 0.1.0

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

@@ -0,0 +1,112 @@
+/*
+ * 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 _VMSTRUCTS_H
+#define _VMSTRUCTS_H
+
+#include <jvmti.h>
+#include <stdint.h>
+#include "codeCache.h"
+
+
+class VMStructs {
+  protected:
+    static int _klass_name_offset;
+    static int _symbol_length_offset;
+    static int _symbol_length_and_refcount_offset;
+    static int _symbol_body_offset;
+    static int _class_klass_offset;
+    static int _thread_osthread_offset;
+    static int _osthread_id_offset;
+    static bool _has_perm_gen;
+    static jfieldID _eetop;
+
+    const char* at(int offset) {
+        return (const char*)this + offset;
+    }
+
+  public:
+    static void init(NativeCodeCache* libjvm);
+
+    static bool available() {
+        return _klass_name_offset >= 0
+            && (_symbol_length_offset >= 0 || _symbol_length_and_refcount_offset >= 0)
+            && _symbol_body_offset >= 0
+            && _class_klass_offset >= 0;
+    }
+
+    static bool hasPermGen() {
+        return _has_perm_gen;
+    }
+};
+
+
+class VMSymbol : VMStructs {
+  public:
+    unsigned short length() {
+        if (_symbol_length_offset >= 0) {
+          return *(unsigned short*) at(_symbol_length_offset);
+        } else {
+          int length_and_refcount = *(unsigned int*) at(_symbol_length_and_refcount_offset);
+          return (length_and_refcount >> 16) & 0xffff;
+        }
+    }
+
+    const char* body() {
+        return at(_symbol_body_offset);
+    }
+};
+
+class VMKlass : VMStructs {
+  public:
+    static VMKlass* fromHandle(uintptr_t handle) {
+        if (_has_perm_gen) {
+            // On JDK 7 KlassHandle is a pointer to klassOop, hence one more indirection
+            return (VMKlass*)(*(uintptr_t**)handle + 2);
+        } else {
+            return (VMKlass*)handle;
+        }
+    }
+
+    VMSymbol* name() {
+        return *(VMSymbol**) at(_klass_name_offset);
+    }
+};
+
+class java_lang_Class : VMStructs {
+  public:
+    VMKlass* klass() {
+        return *(VMKlass**) at(_class_klass_offset);
+    }
+};
+
+class VMThread : VMStructs {
+  public:
+    static bool available() {
+        return _eetop != NULL;
+    }
+
+    static VMThread* fromJavaThread(JNIEnv* env, jthread thread) {
+        return (VMThread*)(uintptr_t)env->GetLongField(thread, _eetop);
+    }
+
+    int osThreadId() {
+        const char* osthread = *(const char**) at(_thread_osthread_offset);
+        return *(int*)(osthread + _osthread_id_offset);
+    }
+};
+
+#endif // _VMSTRUCTS_H

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

@@ -0,0 +1,96 @@
+/*
+ * 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 <poll.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include "wallClock.h"
+#include "os.h"
+#include "profiler.h"
+
+
+const int THREADS_PER_TICK = 8;
+
+long WallClock::_interval;
+bool WallClock::_sample_idle_threads;
+
+void WallClock::signalHandler(int signo, siginfo_t* siginfo, void* ucontext) {
+    Profiler::_instance.recordSample(ucontext, _interval, 0, NULL);
+}
+
+Error WallClock::start(Arguments& args) {
+    if (args._interval < 0) {
+        return Error("interval must be positive");
+    }
+    _interval = args._interval ? args._interval : DEFAULT_INTERVAL;
+    _sample_idle_threads = strcmp(args._event, EVENT_WALL) == 0;
+
+    OS::installSignalHandler(SIGPROF, signalHandler);
+
+    if (pipe(_pipefd) != 0) {
+        return Error("Unable to create poll pipe");
+    }
+
+    if (pthread_create(&_thread, NULL, threadEntry, this) != 0) {
+        close(_pipefd[1]);
+        close(_pipefd[0]);
+        return Error("Unable to create timer thread");
+    }
+
+    return Error::OK;
+}
+
+void WallClock::stop() {
+    char val = 1;
+    ssize_t r = write(_pipefd[1], &val, sizeof(val));
+    (void)r;
+
+    close(_pipefd[1]);
+    pthread_join(_thread, NULL);
+    close(_pipefd[0]);
+}
+
+void WallClock::timerLoop() {
+    ThreadList* thread_list = NULL;
+
+    int self = OS::threadId();
+    bool sample_idle_threads = _sample_idle_threads;
+    struct pollfd fds = {_pipefd[0], POLLIN, 0};
+    int timeout = _interval > 1000000 ? (int)(_interval / 1000000) : 1;
+
+    while (poll(&fds, 1, timeout) == 0) {
+        if (thread_list == NULL) {
+            thread_list = OS::listThreads();
+        }
+
+        for (int count = 0; count < THREADS_PER_TICK; ) {
+            int thread_id = thread_list->next();
+            if (thread_id == -1) {
+                delete thread_list;
+                thread_list = NULL;
+                break;
+            }
+            if (thread_id != self && (sample_idle_threads || OS::isThreadRunning(thread_id))) {
+                OS::sendSignalToThread(thread_id, SIGPROF);
+                count++;
+            }
+        }
+    }
+
+    delete thread_list;
+}

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

@@ -0,0 +1,56 @@
+/*
+ * 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 _WALLCLOCK_H
+#define _WALLCLOCK_H
+
+#include <jvmti.h>
+#include <signal.h>
+#include <pthread.h>
+#include "engine.h"
+
+
+class WallClock : public Engine {
+  private:
+    static long _interval;
+    static bool _sample_idle_threads;
+
+    int _pipefd[2];
+    pthread_t _thread;
+
+    void timerLoop();
+
+    static void* threadEntry(void* wall_clock) {
+        ((WallClock*)wall_clock)->timerLoop();
+        return NULL;
+    }
+
+    static void signalHandler(int signo, siginfo_t* siginfo, void* ucontext);
+
+  public:
+    const char* name() {
+        return _sample_idle_threads ? EVENT_WALL : EVENT_CPU;
+    }
+
+    const char* units() {
+        return "ns";
+    }
+
+    Error start(Arguments& args);
+    void stop();
+};
+
+#endif // _WALLCLOCK_H

data/ext/async-profiler/test/AllocatingTarget.java

@@ -0,0 +1,26 @@
+import java.util.Random;
+
+public class AllocatingTarget implements Runnable {
+    public static volatile Object sink;
+
+    public static void main(String[] args) {
+        new Thread(new AllocatingTarget(), "AllocThread-1").start();
+        new Thread(new AllocatingTarget(), "AllocThread-2").start();
+    }
+
+    @Override
+    public void run() {
+        Random random = new Random();
+        while (true) {
+            allocate(random);
+        }
+    }
+
+    private static void allocate(Random random) {
+        if (random.nextBoolean()) {
+            sink = new int[128 * 1000];
+        } else {
+            sink = new Integer[128 * 1000];
+        }
+    }
+}

data/ext/async-profiler/test/LoadLibraryTest.java

@@ -0,0 +1,21 @@
+import java.lang.management.ClassLoadingMXBean;
+import java.lang.management.ManagementFactory;
+
+class LoadLibraryTest {
+
+    public static void main(String[] args) throws Exception {
+        for (int i = 0; i < 200; i++) {
+            Thread.sleep(10);
+        }
+
+        // Late load of libmanagement.so
+        ClassLoadingMXBean bean = ManagementFactory.getClassLoadingMXBean();
+
+        long n = 0;
+        while (n >= 0) {
+            n += bean.getLoadedClassCount();
+            n += bean.getTotalLoadedClassCount();
+            n += bean.getUnloadedClassCount();
+        }
+    }
+}

data/ext/async-profiler/test/Target.java

@@ -0,0 +1,31 @@
+import java.io.File;
+
+class Target {
+    private static volatile int value;
+
+    private static void method1() {
+        for (int i = 0; i < 1000000; ++i)
+            ++value;
+    }
+
+    private static void method2() {
+        for (int i = 0; i < 1000000; ++i)
+            ++value;
+    }
+
+    private static void method3() throws Exception {
+        for (int i = 0; i < 1000; ++i) {
+            for (String s : new File("/tmp").list()) {
+                value += s.hashCode();
+            }
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+        while (true) {
+            method1();
+            method2();
+            method3();
+        }
+    }
+}

data/ext/async-profiler/test/ThreadsTarget.java

@@ -0,0 +1,35 @@
+import java.math.BigInteger;
+
+public class ThreadsTarget {
+    public static void main(String[] args) {
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                methodForThreadEarlyEnd();
+            }
+        }, "ThreadEarlyEnd").start();
+        new Thread(new Runnable() {
+            @Override
+            public void run() {
+                Thread.currentThread().setName("RenamedThread");
+                methodForRenamedThread();
+            }
+        }, "ThreadWillBeRenamed").start();
+    }
+
+    static void methodForThreadEarlyEnd() {
+        long now = System.currentTimeMillis();
+        BigInteger counter = BigInteger.ZERO;
+        while (System.currentTimeMillis() - now < 300) {
+            counter = counter.nextProbablePrime();
+        }
+    }
+
+    static void methodForRenamedThread() {
+        long now = System.currentTimeMillis();
+        BigInteger counter = BigInteger.ZERO;
+        while (System.currentTimeMillis() - now < 1000) {
+            counter = counter.nextProbablePrime();
+        }
+    }
+}

data/ext/async-profiler/test/alloc-smoke-test.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+set -e  # exit on any failure
+set -x  # print all executed lines
+
+if [ -z "${JAVA_HOME}" ]; then
+  echo "JAVA_HOME is not set"
+  exit 1
+fi
+
+(
+  cd $(dirname $0)
+
+  if [ "AllocatingTarget.class" -ot "AllocatingTarget.java" ]; then
+     ${JAVA_HOME}/bin/javac AllocatingTarget.java
+  fi
+
+  ${JAVA_HOME}/bin/java AllocatingTarget &
+
+  FILENAME=/tmp/java.trace
+  JAVAPID=$!
+
+  sleep 1     # allow the Java runtime to initialize
+  ../profiler.sh -f $FILENAME -o collapsed -d 5 -e alloc -t $JAVAPID
+
+  kill $JAVAPID
+
+  function assert_string() {
+    if ! grep -q "$1" $FILENAME; then
+      exit 1
+    fi
+  }
+
+  assert_string "\[AllocThread-1 tid=[0-9]\+\];.*AllocatingTarget.allocate;.*java.lang.Integer\[\]"
+  assert_string "\[AllocThread-2 tid=[0-9]\+\];.*AllocatingTarget.allocate;.*int\[\]"
+)

data/ext/async-profiler/test/load-library-test.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+set -e  # exit on any failure
+set -x  # print all executed lines
+
+if [ -z "${JAVA_HOME}" ]; then
+  echo "JAVA_HOME is not set"
+  exit 1
+fi
+
+(
+  cd $(dirname $0)
+
+  if [ "LoadLibraryTest.class" -ot "LoadLibraryTest.java" ]; then
+     ${JAVA_HOME}/bin/javac LoadLibraryTest.java
+  fi
+
+  ${JAVA_HOME}/bin/java LoadLibraryTest &
+
+  FILENAME=/tmp/java.trace
+  JAVAPID=$!
+
+  sleep 1     # allow the Java runtime to initialize
+  ../profiler.sh -f $FILENAME -o collapsed -d 5 -i 1ms $JAVAPID
+
+  kill $JAVAPID
+
+  function assert_string() {
+    if ! grep -q "$1" $FILENAME; then
+      exit 1
+    fi
+  }
+
+  assert_string "Java_sun_management"
+)