corkscrews 0.1.0

data/ext/corkscrews/hooks.c

@@ -0,0 +1,156 @@
+#include "corkscrews_native.h"
+
+#include <time.h>
+
+static rb_internal_thread_event_hook_t *thread_hook = NULL;
+static uint64_t gc_enter_started_ns = 0;
+static int gc_hooks_installed = 0;
+
+static uint64_t
+monotonic_ns(void)
+{
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    return ((uint64_t)ts.tv_sec * 1000000000ULL) + (uint64_t)ts.tv_nsec;
+}
+
+static void
+increment_state_bucket(uint8_t state)
+{
+    if (state == 0) atomic_fetch_add(&cs_global.thread_state_running, 1);
+    else if (state == 1) atomic_fetch_add(&cs_global.thread_state_ready, 1);
+    else if (state == 2) atomic_fetch_add(&cs_global.thread_state_suspended, 1);
+    else atomic_fetch_add(&cs_global.thread_state_dead, 1);
+}
+
+static void
+decrement_state_bucket(uint8_t state)
+{
+    if (state == 0) atomic_fetch_sub(&cs_global.thread_state_running, 1);
+    else if (state == 1) atomic_fetch_sub(&cs_global.thread_state_ready, 1);
+    else if (state == 2) atomic_fetch_sub(&cs_global.thread_state_suspended, 1);
+    else atomic_fetch_sub(&cs_global.thread_state_dead, 1);
+}
+
+static void
+update_max_live_threads(uint64_t live)
+{
+    uint64_t current = atomic_load(&cs_global.thread_max_live_count);
+    while (live > current &&
+           !atomic_compare_exchange_weak(&cs_global.thread_max_live_count, &current, live)) {
+    }
+}
+
+static void
+transition_thread_state(cs_thread_t *data, uint8_t next_state)
+{
+    uint8_t initialized = atomic_exchange(&data->state_initialized, 1);
+    uint8_t previous = atomic_exchange(&data->state, next_state);
+
+    if (initialized) {
+        decrement_state_bucket(previous);
+        if (previous != 3 && next_state == 3) {
+            atomic_fetch_sub(&cs_global.thread_live_count, 1);
+        }
+        else if (previous == 3 && next_state != 3) {
+            uint64_t live = atomic_fetch_add(&cs_global.thread_live_count, 1) + 1;
+            update_max_live_threads(live);
+        }
+    }
+    else if (next_state != 3) {
+        uint64_t live = atomic_fetch_add(&cs_global.thread_live_count, 1) + 1;
+        update_max_live_threads(live);
+    }
+
+    increment_state_bucket(next_state);
+}
+
+static void
+thread_event_callback(rb_event_flag_t event, const rb_internal_thread_event_data_t *event_data, void *user_data)
+{
+    (void)user_data;
+    cs_thread_t *data = cs_thread_data_for(event_data->thread, event != RUBY_INTERNAL_THREAD_EVENT_EXITED);
+    if (!data) return;
+
+    if (event == RUBY_INTERNAL_THREAD_EVENT_STARTED) {
+        transition_thread_state(data, 0);
+        atomic_fetch_add(&cs_global.thread_events_started, 1);
+    }
+    else if (event == RUBY_INTERNAL_THREAD_EVENT_READY) {
+        transition_thread_state(data, 1);
+        atomic_fetch_add(&cs_global.thread_events_ready, 1);
+    }
+    else if (event == RUBY_INTERNAL_THREAD_EVENT_RESUMED) {
+        transition_thread_state(data, 0);
+        atomic_fetch_add(&cs_global.thread_events_resumed, 1);
+        cs_delay_request_settle();
+    }
+    else if (event == RUBY_INTERNAL_THREAD_EVENT_SUSPENDED) {
+        transition_thread_state(data, 2);
+        atomic_store(&data->suspended_since_id, atomic_load(&cs_global.experiment_id));
+        atomic_fetch_add(&cs_global.thread_events_suspended, 1);
+    }
+    else if (event == RUBY_INTERNAL_THREAD_EVENT_EXITED) {
+        transition_thread_state(data, 3);
+        atomic_fetch_add(&cs_global.thread_events_exited, 1);
+    }
+}
+
+static void
+gc_event_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
+{
+    (void)data;
+    (void)self;
+    (void)mid;
+    (void)klass;
+
+    if (event == RUBY_INTERNAL_EVENT_GC_ENTER) {
+        gc_enter_started_ns = monotonic_ns();
+        atomic_fetch_add(&cs_global.gc_enter_count, 1);
+    }
+    else if (event == RUBY_INTERNAL_EVENT_GC_EXIT) {
+        uint64_t now = monotonic_ns();
+        if (gc_enter_started_ns > 0 && now > gc_enter_started_ns) {
+            uint64_t pause_ns = now - gc_enter_started_ns;
+            atomic_fetch_add(&cs_global.gc_pause_ns, pause_ns);
+            uint32_t speedup = atomic_load(&cs_global.speedup_pct);
+            if (atomic_load(&cs_global.target_kind) == 2 && speedup > 0) {
+                atomic_fetch_add(&cs_global.vclock_credit_ns, pause_ns * speedup / 100);
+            }
+        }
+        atomic_fetch_add(&cs_global.gc_exit_count, 1);
+    }
+}
+
+static VALUE
+hooks_install(VALUE self)
+{
+    (void)self;
+    if (!thread_hook) {
+        thread_hook = rb_internal_thread_add_event_hook(
+            thread_event_callback,
+            RUBY_INTERNAL_THREAD_EVENT_MASK,
+            NULL
+        );
+    }
+    if (!gc_hooks_installed) {
+        rb_add_event_hook(gc_event_hook, RUBY_INTERNAL_EVENT_GC_ENTER | RUBY_INTERNAL_EVENT_GC_EXIT, Qnil);
+        gc_hooks_installed = 1;
+    }
+    return Qtrue;
+}
+
+static VALUE
+hooks_available_p(VALUE self)
+{
+    (void)self;
+    return Qtrue;
+}
+
+void
+Init_corkscrews_hooks(VALUE rb_mCorkscrews)
+{
+    VALUE rb_mHooks = rb_define_module_under(rb_mCorkscrews, "Hooks");
+    rb_define_singleton_method(rb_mHooks, "available?", hooks_available_p, 0);
+    rb_define_singleton_method(rb_mHooks, "install!", hooks_install, 0);
+}

data/ext/corkscrews/monitor.c

@@ -0,0 +1,117 @@
+#include "corkscrews_native.h"
+
+#include <pthread.h>
+#include <signal.h>
+#include <time.h>
+
+static pthread_t monitor_thread;
+static pthread_t target_thread;
+static _Atomic int monitor_thread_started;
+
+static void
+sleep_for_sample_period(void)
+{
+    uint64_t ns = atomic_load(&cs_global.sample_period_ns);
+    if (ns == 0) ns = 1000000ULL;
+
+    struct timespec ts;
+    ts.tv_sec = (time_t)(ns / 1000000000ULL);
+    ts.tv_nsec = (long)(ns % 1000000000ULL);
+    nanosleep(&ts, NULL);
+}
+
+static void *
+monitor_loop(void *arg)
+{
+    (void)arg;
+    while (atomic_load(&cs_global.monitor_running)) {
+        sleep_for_sample_period();
+        atomic_fetch_add(&cs_global.monitor_ticks, 1);
+        if (atomic_load(&cs_global.monitor_target_registered)) {
+            if (pthread_kill(target_thread, SIGPROF) == 0) {
+                atomic_fetch_add(&cs_global.monitor_signals, 1);
+            }
+            else {
+                atomic_fetch_add(&cs_global.monitor_signal_failures, 1);
+            }
+        }
+    }
+    return NULL;
+}
+
+static VALUE
+monitor_register_current_thread(VALUE self)
+{
+    (void)self;
+    target_thread = pthread_self();
+    atomic_store(&cs_global.monitor_target_registered, 1);
+    return Qtrue;
+}
+
+static VALUE
+monitor_clear_current_thread(VALUE self)
+{
+    (void)self;
+    atomic_store(&cs_global.monitor_target_registered, 0);
+    return Qtrue;
+}
+
+static VALUE
+monitor_start(VALUE self)
+{
+    (void)self;
+    if (atomic_exchange(&cs_global.monitor_running, 1)) {
+        return Qfalse;
+    }
+
+    if (pthread_create(&monitor_thread, NULL, monitor_loop, NULL) != 0) {
+        atomic_store(&cs_global.monitor_running, 0);
+        rb_raise(rb_eRuntimeError, "failed to start corkscrews monitor thread");
+    }
+
+    atomic_store(&monitor_thread_started, 1);
+    atomic_fetch_add(&cs_global.monitor_start_count, 1);
+    return Qtrue;
+}
+
+static VALUE
+monitor_stop(VALUE self)
+{
+    (void)self;
+    if (!atomic_exchange(&cs_global.monitor_running, 0)) {
+        return Qfalse;
+    }
+
+    if (atomic_exchange(&monitor_thread_started, 0)) {
+        pthread_join(monitor_thread, NULL);
+    }
+
+    atomic_fetch_add(&cs_global.monitor_stop_count, 1);
+    return Qtrue;
+}
+
+static VALUE
+monitor_running_p(VALUE self)
+{
+    (void)self;
+    return atomic_load(&cs_global.monitor_running) ? Qtrue : Qfalse;
+}
+
+static VALUE
+monitor_available_p(VALUE self)
+{
+    (void)self;
+    return Qtrue;
+}
+
+void
+Init_corkscrews_monitor(VALUE rb_mCorkscrews)
+{
+    VALUE rb_mMonitor = rb_define_module_under(rb_mCorkscrews, "Monitor");
+    rb_define_singleton_method(rb_mMonitor, "available?", monitor_available_p, 0);
+    rb_define_singleton_method(rb_mMonitor, "register_current_thread!", monitor_register_current_thread, 0);
+    rb_define_singleton_method(rb_mMonitor, "clear_current_thread!", monitor_clear_current_thread, 0);
+    rb_define_singleton_method(rb_mMonitor, "start!", monitor_start, 0);
+    rb_define_singleton_method(rb_mMonitor, "stop!", monitor_stop, 0);
+    rb_define_singleton_method(rb_mMonitor, "running?", monitor_running_p, 0);
+}

data/ext/corkscrews/record.c

@@ -0,0 +1,109 @@
+#include "corkscrews_native.h"
+
+static cs_record_entry_t record_ring[CS_RECORD_RING_SIZE];
+static _Atomic uint64_t record_head;
+static _Atomic uint64_t record_dropped;
+
+void
+cs_record_line_sample(uintptr_t site_key, uint32_t line, uint8_t target_hit, uint64_t delay_ns)
+{
+    uint64_t sequence = atomic_fetch_add(&record_head, 1);
+    if (sequence >= CS_RECORD_RING_SIZE) {
+        atomic_fetch_add(&record_dropped, 1);
+    }
+
+    cs_record_entry_t *entry = &record_ring[sequence % CS_RECORD_RING_SIZE];
+    entry->site_key = site_key;
+    entry->line = line;
+    entry->target_kind = atomic_load(&cs_global.target_kind);
+    entry->speedup_pct = atomic_load(&cs_global.speedup_pct);
+    entry->experiment_id = atomic_load(&cs_global.experiment_id);
+    entry->delay_ns = delay_ns;
+    entry->target_hit = target_hit;
+    entry->sequence = sequence;
+}
+
+VALUE
+cs_record_snapshot(VALUE self)
+{
+    (void)self;
+    VALUE hash = rb_hash_new();
+    rb_hash_aset(hash, ID2SYM(rb_intern("global_delay_ns")), ULL2NUM(atomic_load(&cs_global.global_delay_ns)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("experiment_id")), ULL2NUM(atomic_load(&cs_global.experiment_id)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("target_kind")), UINT2NUM(atomic_load(&cs_global.target_kind)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("target_iseq")), ULL2NUM(atomic_load(&cs_global.target_iseq)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("target_line")), UINT2NUM(atomic_load(&cs_global.target_line)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("speedup_pct")), UINT2NUM(atomic_load(&cs_global.speedup_pct)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("vclock_credit_ns")), ULL2NUM(atomic_load(&cs_global.vclock_credit_ns)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("samples")), ULL2NUM(atomic_load(&cs_global.samples)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("target_hits")), ULL2NUM(atomic_load(&cs_global.target_hits)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_events_started")), ULL2NUM(atomic_load(&cs_global.thread_events_started)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_events_ready")), ULL2NUM(atomic_load(&cs_global.thread_events_ready)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_events_resumed")), ULL2NUM(atomic_load(&cs_global.thread_events_resumed)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_events_suspended")), ULL2NUM(atomic_load(&cs_global.thread_events_suspended)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_events_exited")), ULL2NUM(atomic_load(&cs_global.thread_events_exited)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_state_running")), ULL2NUM(atomic_load(&cs_global.thread_state_running)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_state_ready")), ULL2NUM(atomic_load(&cs_global.thread_state_ready)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_state_suspended")), ULL2NUM(atomic_load(&cs_global.thread_state_suspended)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_state_dead")), ULL2NUM(atomic_load(&cs_global.thread_state_dead)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_live_count")), ULL2NUM(atomic_load(&cs_global.thread_live_count)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("thread_max_live_count")), ULL2NUM(atomic_load(&cs_global.thread_max_live_count)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("gc_enter_count")), ULL2NUM(atomic_load(&cs_global.gc_enter_count)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("gc_exit_count")), ULL2NUM(atomic_load(&cs_global.gc_exit_count)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("gc_pause_ns")), ULL2NUM(atomic_load(&cs_global.gc_pause_ns)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("debt_settlements")), ULL2NUM(atomic_load(&cs_global.debt_settlements)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("debt_settled_ns")), ULL2NUM(atomic_load(&cs_global.debt_settled_ns)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("monitor_ticks")), ULL2NUM(atomic_load(&cs_global.monitor_ticks)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("monitor_signals")), ULL2NUM(atomic_load(&cs_global.monitor_signals)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("monitor_signal_failures")), ULL2NUM(atomic_load(&cs_global.monitor_signal_failures)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("monitor_start_count")), ULL2NUM(atomic_load(&cs_global.monitor_start_count)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("monitor_stop_count")), ULL2NUM(atomic_load(&cs_global.monitor_stop_count)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("monitor_running")), atomic_load(&cs_global.monitor_running) ? Qtrue : Qfalse);
+    rb_hash_aset(hash, ID2SYM(rb_intern("monitor_target_registered")), atomic_load(&cs_global.monitor_target_registered) ? Qtrue : Qfalse);
+    rb_hash_aset(hash, ID2SYM(rb_intern("record_ring_size")), UINT2NUM(CS_RECORD_RING_SIZE));
+    rb_hash_aset(hash, ID2SYM(rb_intern("record_head")), ULL2NUM(atomic_load(&record_head)));
+    rb_hash_aset(hash, ID2SYM(rb_intern("record_dropped")), ULL2NUM(atomic_load(&record_dropped)));
+    return hash;
+}
+
+static VALUE
+record_events(VALUE self)
+{
+    (void)self;
+    uint64_t head = atomic_load(&record_head);
+    uint64_t start = head > CS_RECORD_RING_SIZE ? head - CS_RECORD_RING_SIZE : 0;
+    VALUE ary = rb_ary_new_capa((long)(head - start));
+
+    for (uint64_t sequence = start; sequence < head; sequence++) {
+        cs_record_entry_t *entry = &record_ring[sequence % CS_RECORD_RING_SIZE];
+        if (entry->sequence != sequence) continue;
+
+        VALUE hash = rb_hash_new();
+        rb_hash_aset(hash, ID2SYM(rb_intern("sequence")), ULL2NUM(entry->sequence));
+        rb_hash_aset(hash, ID2SYM(rb_intern("site_key")), ULL2NUM(entry->site_key));
+        rb_hash_aset(hash, ID2SYM(rb_intern("line")), UINT2NUM(entry->line));
+        rb_hash_aset(hash, ID2SYM(rb_intern("target_kind")), UINT2NUM(entry->target_kind));
+        rb_hash_aset(hash, ID2SYM(rb_intern("speedup_pct")), UINT2NUM(entry->speedup_pct));
+        rb_hash_aset(hash, ID2SYM(rb_intern("experiment_id")), ULL2NUM(entry->experiment_id));
+        rb_hash_aset(hash, ID2SYM(rb_intern("delay_ns")), ULL2NUM(entry->delay_ns));
+        rb_hash_aset(hash, ID2SYM(rb_intern("target_hit")), entry->target_hit ? Qtrue : Qfalse);
+        rb_ary_push(ary, hash);
+    }
+    return ary;
+}
+
+static VALUE
+record_available_p(VALUE self)
+{
+    (void)self;
+    return Qtrue;
+}
+
+void
+Init_corkscrews_record(VALUE rb_mCorkscrews)
+{
+    VALUE rb_mRecord = rb_define_module_under(rb_mCorkscrews, "Record");
+    rb_define_singleton_method(rb_mRecord, "available?", record_available_p, 0);
+    rb_define_singleton_method(rb_mRecord, "snapshot", cs_record_snapshot, 0);
+    rb_define_singleton_method(rb_mRecord, "events", record_events, 0);
+}

data/ext/corkscrews/sampler.c

@@ -0,0 +1,99 @@
+#include "corkscrews_native.h"
+
+#define CS_MAX_DEPTH 64
+
+static void
+record_line_hit(uintptr_t site_key, uint32_t line)
+{
+    atomic_fetch_add(&cs_global.samples, 1);
+
+    /* Paper basis: Coz SOSP'15 Section 3.4 implements virtual
+     * speedups by sampling and inserting delay when the sampled line
+     * matches the current experiment target.
+     * Paper URL: https://arxiv.org/abs/1608.03676 */
+    uint8_t hit = 0;
+    uint64_t delay = 0;
+    uint32_t speedup = atomic_load(&cs_global.speedup_pct);
+    uint32_t kind = atomic_load(&cs_global.target_kind);
+    uint32_t target_line = atomic_load(&cs_global.target_line);
+    uintptr_t target_key = atomic_load(&cs_global.target_iseq);
+    if (kind == 1 && speedup > 0 && line == target_line && site_key == target_key) {
+        uint64_t period = atomic_load(&cs_global.sample_period_ns);
+        delay = period * speedup / 100;
+        hit = 1;
+        atomic_fetch_add(&cs_global.target_hits, 1);
+        cs_delay_issue_for_current(delay);
+        cs_delay_request_settle();
+    }
+    cs_record_line_sample(site_key, line, hit, delay);
+}
+
+static VALUE
+sampler_available_p(VALUE self)
+{
+    (void)self;
+    return Qtrue;
+}
+
+static VALUE
+sampler_sample_current(VALUE self)
+{
+    (void)self;
+    VALUE frames[CS_MAX_DEPTH];
+    int lines[CS_MAX_DEPTH];
+    int n = rb_profile_frames(0, CS_MAX_DEPTH, frames, lines);
+    VALUE ary = rb_ary_new_capa(n);
+
+    atomic_fetch_add(&cs_global.samples, 1);
+    if (n > 0) {
+        uint8_t hit = 0;
+        uint64_t delay = 0;
+        uint32_t speedup = atomic_load(&cs_global.speedup_pct);
+        uint32_t kind = atomic_load(&cs_global.target_kind);
+        uint32_t target_line = atomic_load(&cs_global.target_line);
+        uintptr_t target_key = atomic_load(&cs_global.target_iseq);
+        if (kind == 1 && speedup > 0 && target_key == 0 && (uint32_t)lines[0] == target_line) {
+            uint64_t period = atomic_load(&cs_global.sample_period_ns);
+            delay = period * speedup / 100;
+            hit = 1;
+            atomic_fetch_add(&cs_global.target_hits, 1);
+            cs_delay_issue_for_current(delay);
+            cs_delay_request_settle();
+        }
+        cs_record_line_sample(0, (uint32_t)lines[0], hit, delay);
+    }
+
+    for (int i = 0; i < n; i++) {
+        VALUE frame = rb_hash_new();
+        rb_hash_aset(frame, ID2SYM(rb_intern("frame")), frames[i]);
+        rb_hash_aset(frame, ID2SYM(rb_intern("line")), INT2NUM(lines[i]));
+        rb_ary_push(ary, frame);
+    }
+    return ary;
+}
+
+static VALUE
+sampler_record_line(VALUE self, VALUE line_value)
+{
+    (void)self;
+    record_line_hit(0, NUM2UINT(line_value));
+    return Qnil;
+}
+
+static VALUE
+sampler_record_site(VALUE self, VALUE site_key_value, VALUE line_value)
+{
+    (void)self;
+    record_line_hit((uintptr_t)NUM2ULL(site_key_value), NUM2UINT(line_value));
+    return Qnil;
+}
+
+void
+Init_corkscrews_sampler(VALUE rb_mCorkscrews)
+{
+    VALUE rb_mSampler = rb_define_module_under(rb_mCorkscrews, "Sampler");
+    rb_define_singleton_method(rb_mSampler, "available?", sampler_available_p, 0);
+    rb_define_singleton_method(rb_mSampler, "sample_current", sampler_sample_current, 0);
+    rb_define_singleton_method(rb_mSampler, "record_line", sampler_record_line, 1);
+    rb_define_singleton_method(rb_mSampler, "record_site", sampler_record_site, 2);
+}