jemalloc_ctl 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a11fb9644350e9484a4e0f6e0d7a4a89445ce6284e9ed5dc00bbb0314139ac7d
-  data.tar.gz: d4079ec48055491218452c0f054b742602f61fc55946c418621b7740ca06edcb
+  metadata.gz: 6358746cbb29a35a956a8b738a3b52f2dd643256d48cb76d5ae5e55ff9c093ae
+  data.tar.gz: 135a5d7a5e9ef51bac5709cb99d9fdacbd2f6d0245b72e49405becc270cbc3bb
 SHA512:
-  metadata.gz: 44fcc93f7ac58f5b9e8da956d98e04a5608a4841555be26fa192bff9399e27600ee9048880d9ba15195a17c01f31bd3c501fe00de6e2a3d3b86636c7f791f7e1
-  data.tar.gz: b1162525fed73dd1a16c09d0b33d71c53d83c414e9c3731f1de6e83aa69ad0c9e1bf0a6d917d9db815c3342d4a7627b9c8f5504ba0e1cdf32f2e0c1006511947
+  metadata.gz: 24b769826c3f509efc442aeca2ee62ce768b27f86b2f9f6ee12e8a624b01420042d0ee2d7b420b73e19e7704e4f6f2172f607e47638d7d7c15377215386b8827
+  data.tar.gz: 7e8ab5599ff137fb5b8fe8efd9e96eda75e9bb1cab439a39bea39d7fb6e9f9f179e8b21b6b239e83c0143383c4b4fc8a4ce01cacca49e9eee5a851a156efbfbc

data/ext/jemalloc_ctl/jemalloc_ctl.c

@@ -1,4 +1,5 @@
 #include <ruby.h>
+#include <ruby/debug.h>
 #include <dlfcn.h>
 #include <stdbool.h>
 
@@ -33,6 +34,11 @@ static malloc_stats_print_fn my_malloc_stats_print = NULL;
 #endif
 
 static VALUE rb_mJemallocCtl;
+static VALUE rb_eJemallocCtlError;
+static VALUE rb_eJemallocCtlJemallocNotFound;
+
+static VALUE main_thread_val = Qnil;
+static int gc_exit_hook_installed = 0;
 
 static VALUE rb_jemalloc_ctl_enabled_p(VALUE self)
 {
@@ -42,14 +48,14 @@ static VALUE rb_jemalloc_ctl_enabled_p(VALUE self)
 static VALUE rb_jemalloc_ctl_version(VALUE self)
 {
     if (my_mallctl == NULL)
-        rb_raise(rb_eRuntimeError, "jemalloc is not available");
+        rb_raise(rb_eJemallocCtlJemallocNotFound, "jemalloc is not available");
 
     const char *version;
     size_t sz = sizeof(version);
     int err = my_mallctl("version", &version, &sz, NULL, 0);
 
     if (err != 0)
-        rb_raise(rb_eRuntimeError, "mallctl(\"version\") failed with error %d", err);
+        rb_raise(rb_eJemallocCtlError, "mallctl(\"version\") failed with error %d", err);
 
     return rb_str_new_cstr(version);
 }
@@ -57,13 +63,13 @@ static VALUE rb_jemalloc_ctl_version(VALUE self)
 static VALUE rb_jemalloc_ctl_toggle_background_thread(VALUE self, VALUE onoff)
 {
     if (my_mallctl == NULL)
-        rb_raise(rb_eRuntimeError, "jemalloc is not available");
+        rb_raise(rb_eJemallocCtlJemallocNotFound, "jemalloc is not available");
 
     bool val = RTEST(onoff);
     int err = my_mallctl("background_thread", NULL, NULL, &val, sizeof(bool));
 
     if (err != 0)
-        rb_raise(rb_eRuntimeError, "mallctl(\"background_thread\") failed with error %d", err);
+        rb_raise(rb_eJemallocCtlError, "mallctl(\"background_thread\") failed with error %d", err);
 
     return Qtrue;
 }
@@ -71,13 +77,13 @@ static VALUE rb_jemalloc_ctl_toggle_background_thread(VALUE self, VALUE onoff)
 static VALUE rb_jemalloc_ctl_toggle_current_thread_tcache(VALUE self, VALUE onoff)
 {
     if (my_mallctl == NULL)
-        rb_raise(rb_eRuntimeError, "jemalloc is not available");
+        rb_raise(rb_eJemallocCtlJemallocNotFound, "jemalloc is not available");
 
     bool enabled = RTEST(onoff);
     int err = my_mallctl("thread.tcache.enabled", NULL, NULL, &enabled, sizeof(enabled));
 
     if (err != 0)
-        rb_raise(rb_eRuntimeError, "mallctl(\"thread.tcache.enabled\") failed with error %d", err);
+        rb_raise(rb_eJemallocCtlError, "mallctl(\"thread.tcache.enabled\") failed with error %d", err);
 
     return Qtrue;
 }
@@ -85,20 +91,56 @@ static VALUE rb_jemalloc_ctl_toggle_current_thread_tcache(VALUE self, VALUE onof
 static VALUE rb_jemalloc_ctl_flush_current_thread_tcache(VALUE self)
 {
     if (my_mallctl == NULL)
-        rb_raise(rb_eRuntimeError, "jemalloc is not available");
+        rb_raise(rb_eJemallocCtlJemallocNotFound, "jemalloc is not available");
 
     int err = my_mallctl("thread.tcache.flush", NULL, NULL, NULL, 0);
 
     if (err != 0)
-        rb_raise(rb_eRuntimeError, "mallctl(\"thread.tcache.flush\") failed with error %d", err);
+        rb_raise(rb_eJemallocCtlError, "mallctl(\"thread.tcache.flush\") failed with error %d", err);
+
+    return Qtrue;
+}
+
+static void gc_exit_tcache_flush_hook(rb_event_flag_t flag, VALUE data,
+                                       VALUE self, ID mid, VALUE klass)
+{
+    // Runs inside GC: must not allocate Ruby objects or raise.
+    if (my_mallctl == NULL) return;
+    if (rb_thread_current() == main_thread_val) return;
+    my_mallctl("thread.tcache.flush", NULL, NULL, NULL, 0);
+}
+
+static VALUE rb_jemalloc_ctl_enable_gc_exit_tcache_flush(VALUE self)
+{
+    if (my_mallctl == NULL)
+        rb_raise(rb_eJemallocCtlJemallocNotFound, "jemalloc is not available");
+
+    if (gc_exit_hook_installed)
+        return Qfalse;
+
+    if (main_thread_val == Qnil) {
+        main_thread_val = rb_thread_main();
+        rb_gc_register_address(&main_thread_val);
+    }
+    rb_add_event_hook(gc_exit_tcache_flush_hook, RUBY_INTERNAL_EVENT_GC_EXIT, Qnil);
+    gc_exit_hook_installed = 1;
+    return Qtrue;
+}
+
+static VALUE rb_jemalloc_ctl_disable_gc_exit_tcache_flush(VALUE self)
+{
+    if (!gc_exit_hook_installed)
+        return Qfalse;
 
+    rb_remove_event_hook(gc_exit_tcache_flush_hook);
+    gc_exit_hook_installed = 0;
     return Qtrue;
 }
 
 static VALUE rb_jemalloc_ctl_purge_arenas(VALUE self)
 {
     if (my_mallctl == NULL)
-        rb_raise(rb_eRuntimeError, "jemalloc is not available");
+        rb_raise(rb_eJemallocCtlJemallocNotFound, "jemalloc is not available");
 
     char ctl[32];
     snprintf(ctl, sizeof(ctl), "arena.%d.purge", MALLCTL_ARENAS_ALL);
@@ -106,7 +148,7 @@ static VALUE rb_jemalloc_ctl_purge_arenas(VALUE self)
     int err = my_mallctl(ctl, NULL, NULL, NULL, 0);
 
     if (err != 0)
-        rb_raise(rb_eRuntimeError, "mallctl(\"%s\") failed with error %d", ctl, err);
+        rb_raise(rb_eJemallocCtlError, "mallctl(\"%s\") failed with error %d", ctl, err);
 
     return Qtrue;
 }
@@ -119,7 +161,7 @@ static void write_stats_cb(void *opaque, const char *buf)
 static VALUE rb_jemalloc_ctl_print_stats(VALUE self, VALUE filename)
 {
     if (my_malloc_stats_print == NULL)
-        rb_raise(rb_eRuntimeError, "malloc_stats_print is not available");
+        rb_raise(rb_eJemallocCtlError, "malloc_stats_print is not available");
 
     const char *path = StringValueCStr(filename);
     FILE *f = fopen(path, "w");
@@ -173,6 +215,8 @@ void Init_jemalloc_ctl(void)
 #endif
 
     rb_mJemallocCtl = rb_define_module("JemallocCtl");
+    rb_eJemallocCtlError = rb_define_class_under(rb_mJemallocCtl, "Error", rb_eStandardError);
+    rb_eJemallocCtlJemallocNotFound = rb_define_class_under(rb_mJemallocCtl, "JemallocNotFound", rb_eJemallocCtlError);
     rb_define_singleton_method(rb_mJemallocCtl, "enabled?", rb_jemalloc_ctl_enabled_p, 0);
     rb_define_singleton_method(rb_mJemallocCtl, "version", rb_jemalloc_ctl_version, 0);
     rb_define_singleton_method(rb_mJemallocCtl, "print_stats", rb_jemalloc_ctl_print_stats, 1);
@@ -180,4 +224,6 @@ void Init_jemalloc_ctl(void)
     rb_define_singleton_method(rb_mJemallocCtl, "purge_arenas", rb_jemalloc_ctl_purge_arenas, 0);
     rb_define_singleton_method(rb_mJemallocCtl, "flush_current_thread_tcache", rb_jemalloc_ctl_flush_current_thread_tcache, 0);
     rb_define_singleton_method(rb_mJemallocCtl, "toggle_current_thread_tcache", rb_jemalloc_ctl_toggle_current_thread_tcache, 1);
+    rb_define_singleton_method(rb_mJemallocCtl, "enable_gc_exit_tcache_flush!", rb_jemalloc_ctl_enable_gc_exit_tcache_flush, 0);
+    rb_define_singleton_method(rb_mJemallocCtl, "disable_gc_exit_tcache_flush!", rb_jemalloc_ctl_disable_gc_exit_tcache_flush, 0);
 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jemalloc_ctl
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Luke Gruber