jruby-async-profiler 0.1.0

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

@@ -0,0 +1,152 @@
+/*
+ * 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 _ARGUMENTS_H
+#define _ARGUMENTS_H
+
+#include <stddef.h>
+
+
+const long DEFAULT_INTERVAL = 10000000;  // 10 ms
+const int DEFAULT_FRAMEBUF = 1000000;
+const int DEFAULT_JSTACKDEPTH = 2048;
+
+const char* const EVENT_CPU    = "cpu";
+const char* const EVENT_ALLOC  = "alloc";
+const char* const EVENT_LOCK   = "lock";
+const char* const EVENT_WALL   = "wall";
+const char* const EVENT_ITIMER = "itimer";
+
+enum Action {
+    ACTION_NONE,
+    ACTION_START,
+    ACTION_RESUME,
+    ACTION_STOP,
+    ACTION_STATUS,
+    ACTION_LIST,
+    ACTION_VERSION,
+    ACTION_DUMP
+};
+
+enum Counter {
+    COUNTER_SAMPLES,
+    COUNTER_TOTAL
+};
+
+enum Ring {
+    RING_ANY,
+    RING_KERNEL,
+    RING_USER
+};
+
+enum Style {
+    STYLE_SIMPLE     = 1,
+    STYLE_DOTTED     = 2,
+    STYLE_SIGNATURES = 4,
+    STYLE_ANNOTATE   = 8
+};
+
+enum Output {
+    OUTPUT_NONE,
+    OUTPUT_TEXT,
+    OUTPUT_COLLAPSED,
+    OUTPUT_FLAMEGRAPH,
+    OUTPUT_TREE,
+    OUTPUT_JFR
+};
+
+
+class Error {
+  private:
+    const char* _message;
+
+  public:
+    static const Error OK;
+
+    explicit Error(const char* message) : _message(message) {
+    }
+
+    const char* message() {
+        return _message;
+    }
+
+    operator bool() {
+        return _message != NULL;
+    }
+};
+
+
+class Arguments {
+  private:
+    char* _buf;
+
+    static const char* expandFilePattern(char* dest, size_t max_size, const char* pattern);
+    static Output detectOutputFormat(const char* file);
+    static long parseUnits(const char* str);
+
+  public:
+    Action _action;
+    Counter _counter;
+    Ring _ring;
+    const char* _event;
+    long _interval;
+    int  _jstackdepth;
+    int _framebuf;
+    bool _threads;
+    bool _sync_walk;
+    int _style;
+    const char* _file;
+    Output _output;
+    int _dump_traces;
+    int _dump_flat;
+    // FlameGraph parameters
+    const char* _title;
+    int _width;
+    int _height;
+    double _minwidth;
+    bool _reverse;
+
+    Arguments() :
+        _buf(NULL),
+        _action(ACTION_NONE),
+        _counter(COUNTER_SAMPLES),
+        _ring(RING_ANY),
+        _event(EVENT_CPU),
+        _interval(0),
+        _jstackdepth(DEFAULT_JSTACKDEPTH),
+        _framebuf(DEFAULT_FRAMEBUF),
+        _threads(false),
+        _sync_walk(false),
+        _style(0),
+        _file(NULL),
+        _output(OUTPUT_NONE),
+        _dump_traces(0),
+        _dump_flat(0),
+        _title("Flame Graph"),
+        _width(1200),
+        _height(16),
+        _minwidth(0.25),
+        _reverse(false) {
+    }
+
+    ~Arguments();
+
+    void save(Arguments& other);
+
+    Error parse(const char* args);
+};
+
+#endif // _ARGUMENTS_H

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

@@ -0,0 +1,128 @@
+/*
+ * 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 <stdlib.h>
+#include <string.h>
+#include "codeCache.h"
+
+
+void CodeCache::expand() {
+    CodeBlob* old_blobs = _blobs;
+    CodeBlob* new_blobs = new CodeBlob[_capacity * 2];
+    memcpy(new_blobs, old_blobs, _capacity * sizeof(CodeBlob));
+    _capacity *= 2;
+    _blobs = new_blobs;
+    delete[] old_blobs;
+}
+
+void CodeCache::add(const void* start, int length, jmethodID method) {
+    if (_count >= _capacity) {
+        expand();
+    }
+
+    _blobs[_count]._start = start;
+    _blobs[_count]._end = (const char*)start + length;
+    _blobs[_count]._method = method;
+    _count++;
+}
+
+void CodeCache::remove(const void* start, jmethodID method) {
+    for (int i = 0; i < _count; i++) {
+        if (_blobs[i]._start == start && _blobs[i]._method == method) {
+            _blobs[i]._method = NULL;
+            return;
+        }
+    }
+}
+
+jmethodID CodeCache::find(const void* address) {
+    for (int i = 0; i < _count; i++) {
+        if (address >= _blobs[i]._start && address < _blobs[i]._end) {
+            return _blobs[i]._method;
+        }
+    }
+    return NULL;
+}
+
+
+NativeCodeCache::NativeCodeCache(const char* name, const void* min_address, const void* max_address) {
+    _name = strdup(name);
+    _min_address = min_address;
+    _max_address = max_address;
+}
+
+NativeCodeCache::~NativeCodeCache() {
+    for (int i = 0; i < _count; i++) {
+        free(_blobs[i]._method);
+    }
+    free(_name);
+}
+
+void NativeCodeCache::add(const void* start, int length, const char* name) {
+    CodeCache::add(start, length, (jmethodID)strdup(name));
+}
+
+void NativeCodeCache::sort() {
+    if (_count == 0) return;
+
+    qsort(_blobs, _count, sizeof(CodeBlob), CodeBlob::comparator);
+
+    if (_min_address == NULL) _min_address = _blobs[0]._start;
+    if (_max_address == NULL) _max_address = _blobs[_count - 1]._end;
+}
+
+const char* NativeCodeCache::binarySearch(const void* address) {
+    int low = 0;
+    int high = _count - 1;
+
+    while (low <= high) {
+        int mid = (unsigned int)(low + high) >> 1;
+        if (_blobs[mid]._end <= address) {
+            low = mid + 1;
+        } else if (_blobs[mid]._start > address) {
+            high = mid - 1;
+        } else {
+            return (const char*)_blobs[mid]._method;
+        }
+    }
+
+    // Symbols with zero size can be valid functions: e.g. ASM entry points or kernel code
+    if (low > 0 && _blobs[low - 1]._start == _blobs[low - 1]._end) {
+        return (const char*)_blobs[low - 1]._method;
+    }
+    return _name;
+}
+
+const void* NativeCodeCache::findSymbol(const char* name) {
+    for (int i = 0; i < _count; i++) {
+        const char* blob_name = (const char*)_blobs[i]._method;
+        if (blob_name != NULL && strcmp(blob_name, name) == 0) {
+            return _blobs[i]._start;
+        }
+    }
+    return NULL;
+}
+
+const void* NativeCodeCache::findSymbolByPrefix(const char* prefix) {
+    int prefix_len = strlen(prefix);
+    for (int i = 0; i < _count; i++) {
+        const char* blob_name = (const char*)_blobs[i]._method;
+        if (blob_name != NULL && strncmp(blob_name, prefix, prefix_len) == 0) {
+            return _blobs[i]._start;
+        }
+    }
+    return NULL;
+}

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

@@ -0,0 +1,99 @@
+/*
+ * 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 _CODECACHE_H
+#define _CODECACHE_H
+
+#include <jvmti.h>
+
+
+const int INITIAL_CODE_CACHE_CAPACITY = 1000;
+
+
+class CodeBlob {
+  public:
+    const void* _start;
+    const void* _end;
+    jmethodID _method;
+
+    static int comparator(const void* c1, const void* c2) {
+        CodeBlob* cb1 = (CodeBlob*)c1;
+        CodeBlob* cb2 = (CodeBlob*)c2;
+        if (cb1->_start < cb2->_start) {
+            return -1;
+        } else if (cb1->_start > cb2->_start) {
+            return 1;
+        } else if (cb1->_end == cb2->_end) {
+            return 0;
+        } else {
+            return cb1->_end > cb2->_end ? -1 : 1;
+        }
+    }
+};
+
+
+class CodeCache {
+  protected:
+    int _capacity;
+    int _count;
+    CodeBlob* _blobs;
+
+    void expand();
+
+  public:
+    CodeCache() {
+        _capacity = INITIAL_CODE_CACHE_CAPACITY;
+        _count = 0;
+        _blobs = new CodeBlob[_capacity];
+    }
+
+    ~CodeCache() {
+        delete[] _blobs;
+    }
+
+    void add(const void* start, int length, jmethodID method);
+    void remove(const void* start, jmethodID method);
+    jmethodID find(const void* address);
+};
+
+
+class NativeCodeCache : public CodeCache {
+  private:
+    char* _name;
+    const void* _min_address;
+    const void* _max_address;
+  
+  public:
+    NativeCodeCache(const char* name, const void* min_address = NULL, const void* max_address = NULL);
+
+    ~NativeCodeCache();
+
+    const char* name() {
+        return _name;
+    }
+
+    bool contains(const void* address) {
+        return address >= _min_address && address < _max_address;
+    }
+
+    void add(const void* start, int length, const char* name);
+    void sort();
+    const char* binarySearch(const void* address);
+    const void* findSymbol(const char* name);
+    const void* findSymbolByPrefix(const char* prefix);
+};
+
+#endif // _CODECACHE_H

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

@@ -0,0 +1,50 @@
+/*
+ * 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 "engine.h"
+#include "stackFrame.h"
+
+
+int Engine::getNativeTrace(void* ucontext, int tid, const void** callchain, int max_depth,
+                           const void* jit_min_address, const void* jit_max_address) {
+    StackFrame frame(ucontext);
+    const void* pc = (const void*)frame.pc();
+    uintptr_t fp = frame.fp();
+    uintptr_t prev_fp = (uintptr_t)&fp;
+
+    int depth = 0;
+    const void* const valid_pc = (const void*)0x1000;
+
+    // Walk until the bottom of the stack or until the first Java frame
+    while (depth < max_depth && pc >= valid_pc) {
+        callchain[depth++] = pc;
+
+        if (pc >= jit_min_address && pc < jit_max_address) {
+            break;
+        }
+
+        // Check if the next frame is below on the current stack
+        if (fp <= prev_fp || fp >= prev_fp + 0x40000) {
+            break;
+        }
+
+        prev_fp = fp;
+        pc = ((const void**)fp)[1];
+        fp = ((uintptr_t*)fp)[0];
+    }
+
+    return depth;
+}

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

@@ -0,0 +1,38 @@
+/*
+ * 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 _ENGINE_H
+#define _ENGINE_H
+
+#include "arguments.h"
+
+
+class Engine {
+  public:
+    virtual const char* name() = 0;
+    virtual const char* units() = 0;
+
+    virtual Error start(Arguments& args) = 0;
+    virtual void stop() = 0;
+
+    virtual void onThreadStart() {}
+    virtual void onThreadEnd() {}
+
+    virtual int getNativeTrace(void* ucontext, int tid, const void** callchain, int max_depth,
+                               const void* jit_min_address, const void* jit_max_address);
+};
+
+#endif // _ENGINE_H