jemalloc_ctl 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ab59d11b2bfb3adb1e40476ed0902532eae1436edf9b0e31f64be2dd4f3d8da
-  data.tar.gz: d771262a02cf483a43a85c3d0d643a499e5c5f1cde09bf4be70a5678995010bd
+  metadata.gz: a11fb9644350e9484a4e0f6e0d7a4a89445ce6284e9ed5dc00bbb0314139ac7d
+  data.tar.gz: d4079ec48055491218452c0f054b742602f61fc55946c418621b7740ca06edcb
 SHA512:
-  metadata.gz: 86e68a6ed91e73633fb5cbaa416152d374f266de91ff564e49145e62aa4cd766478b3d626640a4c53a55f5e30d8e47e73acc06d77af641e2fe205d32d5b0e418
-  data.tar.gz: 865191340c23cfb157aa6f74800cf78ee25a21c611d3999813eaec291419cc6ccb9f4de9f6ff52b8d9bffc44ccc0c6aab4e5d71f91174a674d4493a68c32c860
+  metadata.gz: 44fcc93f7ac58f5b9e8da956d98e04a5608a4841555be26fa192bff9399e27600ee9048880d9ba15195a17c01f31bd3c501fe00de6e2a3d3b86636c7f791f7e1
+  data.tar.gz: b1162525fed73dd1a16c09d0b33d71c53d83c414e9c3731f1de6e83aa69ad0c9e1bf0a6d917d9db815c3342d4a7627b9c8f5504ba0e1cdf32f2e0c1006511947

data/ext/jemalloc_ctl/jemalloc_ctl.c

@@ -3,11 +3,17 @@
 #include <stdbool.h>
 
 typedef int (*mallctl_fn)(const char *, void *, size_t *, void *, size_t);
+typedef void (*write_cb_t)(void *, const char *);
+typedef void (*malloc_stats_print_fn)(write_cb_t, void *, const char *);
 
 static mallctl_fn my_mallctl = NULL;
+static malloc_stats_print_fn my_malloc_stats_print = NULL;
 
 #define JEMALLOC_CTL_DLOPEN_FALLBACK 0
 
+// From jemalloc.h: special arena index meaning "all arenas"
+#define MALLCTL_ARENAS_ALL 4096
+
 #if JEMALLOC_CTL_DLOPEN_FALLBACK > 0
     // used for testing
     static const char *jemalloc_lib_names[] = {
@@ -48,12 +54,12 @@ static VALUE rb_jemalloc_ctl_version(VALUE self)
     return rb_str_new_cstr(version);
 }
 
-static VALUE rb_jemalloc_ctl_enable_background_thread(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");
 
-    bool val = true;
+    bool val = RTEST(onoff);
     int err = my_mallctl("background_thread", NULL, NULL, &val, sizeof(bool));
 
     if (err != 0)
@@ -62,34 +68,93 @@ static VALUE rb_jemalloc_ctl_enable_background_thread(VALUE self)
     return Qtrue;
 }
 
-static VALUE rb_jemalloc_ctl_disable_background_thread(VALUE self)
+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");
 
-    bool val = false;
-    int err = my_mallctl("background_thread", NULL, NULL, &val, sizeof(bool));
+    bool enabled = RTEST(onoff);
+    int err = my_mallctl("thread.tcache.enabled", NULL, NULL, &enabled, sizeof(enabled));
 
     if (err != 0)
-        rb_raise(rb_eRuntimeError, "mallctl(\"background_thread\") failed with error %d", err);
+        rb_raise(rb_eRuntimeError, "mallctl(\"thread.tcache.enabled\") failed with error %d", err);
+
+    return Qtrue;
+}
+
+static VALUE rb_jemalloc_ctl_flush_current_thread_tcache(VALUE self)
+{
+    if (my_mallctl == NULL)
+        rb_raise(rb_eRuntimeError, "jemalloc is not available");
+
+    int err = my_mallctl("thread.tcache.flush", NULL, NULL, NULL, 0);
 
-    return Qfalse;
+    if (err != 0)
+        rb_raise(rb_eRuntimeError, "mallctl(\"thread.tcache.flush\") failed with error %d", err);
+
+    return Qtrue;
+}
+
+static VALUE rb_jemalloc_ctl_purge_arenas(VALUE self)
+{
+    if (my_mallctl == NULL)
+        rb_raise(rb_eRuntimeError, "jemalloc is not available");
+
+    char ctl[32];
+    snprintf(ctl, sizeof(ctl), "arena.%d.purge", MALLCTL_ARENAS_ALL);
+
+    int err = my_mallctl(ctl, NULL, NULL, NULL, 0);
+
+    if (err != 0)
+        rb_raise(rb_eRuntimeError, "mallctl(\"%s\") failed with error %d", ctl, err);
+
+    return Qtrue;
+}
+
+static void write_stats_cb(void *opaque, const char *buf)
+{
+    fputs(buf, (FILE *)opaque);
+}
+
+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");
+
+    const char *path = StringValueCStr(filename);
+    FILE *f = fopen(path, "w");
+    if (f == NULL)
+        rb_sys_fail(path);
+
+    my_malloc_stats_print(write_stats_cb, f, NULL);
+
+    fclose(f);
+    return Qtrue;
 }
 
-static mallctl_fn find_mallctl_in(void *handle)
+static bool find_jemalloc_fns_in(void *handle)
 {
     // Try unprefixed (jemalloc as default allocator) then je_-prefixed
-    mallctl_fn fn = (mallctl_fn)dlsym(handle, "mallctl");
-    if (fn == NULL)
-        fn = (mallctl_fn)dlsym(handle, "je_mallctl");
-    return fn;
+    mallctl_fn mallctl = (mallctl_fn)dlsym(handle, "mallctl");
+    if (mallctl == NULL)
+        mallctl = (mallctl_fn)dlsym(handle, "je_mallctl");
+    if (mallctl == NULL)
+        return false;
+
+    malloc_stats_print_fn print_fn = (malloc_stats_print_fn)dlsym(handle, "malloc_stats_print");
+    if (print_fn == NULL)
+        print_fn = (malloc_stats_print_fn)dlsym(handle, "je_malloc_stats_print");
+
+    my_mallctl = mallctl;
+    my_malloc_stats_print = print_fn;
+    return true;
 }
 
 void Init_jemalloc_ctl(void)
 {
     // First: check if mallctl is already in the process
     // (jemalloc compiled into Ruby or LD_PRELOADed)
-    my_mallctl = find_mallctl_in(RTLD_DEFAULT);
+    find_jemalloc_fns_in(RTLD_DEFAULT);
 
 #if JEMALLOC_CTL_DLOPEN_FALLBACK > 0
     // Fallback: try to dlopen jemalloc from common paths
@@ -98,8 +163,7 @@ void Init_jemalloc_ctl(void)
         for (const char **name = jemalloc_lib_names; *name != NULL; name++) {
             jemalloc_handle = dlopen(*name, RTLD_LAZY);
             if (jemalloc_handle != NULL) {
-                my_mallctl = find_mallctl_in(jemalloc_handle);
-                if (my_mallctl != NULL)
+                if (find_jemalloc_fns_in(jemalloc_handle))
                     break;
                 dlclose(jemalloc_handle);
                 jemalloc_handle = NULL;
@@ -111,6 +175,9 @@ void Init_jemalloc_ctl(void)
     rb_mJemallocCtl = rb_define_module("JemallocCtl");
     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, "enable_background_thread", rb_jemalloc_ctl_enable_background_thread, 0);
-    rb_define_singleton_method(rb_mJemallocCtl, "disable_background_thread", rb_jemalloc_ctl_disable_background_thread, 0);
+    rb_define_singleton_method(rb_mJemallocCtl, "print_stats", rb_jemalloc_ctl_print_stats, 1);
+    rb_define_singleton_method(rb_mJemallocCtl, "toggle_background_thread", rb_jemalloc_ctl_toggle_background_thread, 1);
+    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);
 }

data/lib/jemalloc_ctl.rb

@@ -1,3 +1,16 @@
 require "jemalloc_ctl/jemalloc_ctl"
 module JemallocCtl
+  def self.disable_background_thread
+    toggle_background_thread(false)
+  end
+  def self.enable_background_thread
+    toggle_background_thread(true)
+  end
+
+  def self.disable_current_thread_tcache
+    toggle_current_thread_tcache(false)
+  end
+  def self.enable_current_thread_tcache
+    toggle_current_thread_tcache(true)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jemalloc_ctl
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Luke Gruber
@@ -40,5 +40,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.0.6
 specification_version: 4
-summary: Configure jemalloc via mallctl
+summary: Configure jemalloc via mallctl from Ruby
 test_files: []