allocations 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f684c28383cf0174b1410aacedd436771f14603
-  data.tar.gz: c8cb8d726e5edbe6a81005c65ffce812a4688c6a
+  metadata.gz: a46f508510123c761b991e64889ac068ed815bd8
+  data.tar.gz: d68c81c787976c85a8887cc7bdab6968d4edf279
 SHA512:
-  metadata.gz: f17e896bcb848cbbcc59cf5bee39ba3baf318eb995bacf90df28b654143b07a2670a1c55f6e692ac7475f67515783987b56614af01804e70799dc4f6e926f45c
-  data.tar.gz: 325c979378375a49ac0d233abc3cd1bea91b903765dcd9fe7c66a34e52e9b1dd7b01e08fb675179c814f830409cab05d5f4fad51fb7bae9dfddff9758df59239
+  metadata.gz: 2d3b904496f79e974224f08a32ccd5063f15246947a9f74d29278b1205c2c6329b00302865534561dedf666601622ab994b5559b8dd7536a12b31e7ba8142107
+  data.tar.gz: c2ea1a53ac53a20e4b95e59d7ace5ef05890b23885a7af8fd8f9a85a923d499c9c8bccf5cc7d0a609fbddb82b5b325d1cbbf4f598582465927f1d4e62902f2d6

data/ext/liballocations/liballocations.c

@@ -1,12 +1,14 @@
 #include "liballocations.h"
 
-st_table *object_counts;
-
 VALUE allocation_tracer;
 VALUE free_tracer;
+VALUE state_const;
 
 ID id_enabled;
 
+#define IS_SINGLETON(klass) \
+    RB_TYPE_P(klass, T_CLASS) && FL_TEST(klass, FL_SINGLETON)
+
 /**
  * Called whenever a new Ruby object is allocated.
  */
@@ -15,16 +17,23 @@ void newobj_callback(VALUE tracepoint, void* data) {
 
     st_data_t count = 0;
 
-    VALUE obj   = rb_tracearg_object(trace_arg);
-    VALUE klass = RBASIC_CLASS(obj);
+    AllocationState *state = allocation_state_get_struct(state_const);
+
+    VALUE klass = rb_tracearg_defined_class(trace_arg);
 
     /* These aren't actually allocated so there's no point in tracking them. */
     if ( klass == Qtrue || klass == Qfalse || klass == Qnil ) {
         return;
     }
 
-    st_lookup(object_counts, (st_data_t) klass, &count);
-    st_insert(object_counts, (st_data_t) klass, count + 1);
+    // We don't care about sigleton classes since only one of them exists at a
+    // time. The logic here is stolen from MRI's implementation of
+    // Class#singleton_class? as MRI sadly provides no public C function for
+    // this method.
+    if ( IS_SINGLETON(klass) ) return;
+
+    st_lookup(state->object_counts, (st_data_t) klass, &count);
+    st_insert(state->object_counts, (st_data_t) klass, count + 1);
 }
 
 /**
@@ -34,20 +43,22 @@ void newobj_callback(VALUE tracepoint, void* data) {
  * segfault.
  */
 void freeobj_callback(VALUE tracepoint, void* data) {
+    st_data_t count;
+
     rb_trace_arg_t *trace_arg = rb_tracearg_from_tracepoint(tracepoint);
+    AllocationState *state = allocation_state_get_struct(state_const);
 
-    st_data_t count;
+    VALUE klass = rb_tracearg_defined_class(trace_arg);
 
-    VALUE obj   = rb_tracearg_object(trace_arg);
-    VALUE klass = RBASIC_CLASS(obj);
+    if ( IS_SINGLETON(klass) ) return;
 
-    if ( st_lookup(object_counts, (st_data_t) klass, &count) ) {
-        if ( count > 0 && (count - 1) > 0) {
-            st_insert(object_counts, (st_data_t) klass, count - 1);
+    if ( st_lookup(state->object_counts, (st_data_t) klass, &count) ) {
+        if ( count > 0 && (count - 1) > 0 ) {
+            st_insert(state->object_counts, (st_data_t) klass, count - 1);
         }
         /* Remove the entry if the count is now 0 */
         else {
-            st_delete(object_counts, (st_data_t*) &klass, NULL);
+            st_delete(state->object_counts, (st_data_t*) &klass, NULL);
         }
     }
 }
@@ -58,9 +69,7 @@ void freeobj_callback(VALUE tracepoint, void* data) {
 static int each_count(st_data_t key, st_data_t value, st_data_t hash_ptr) {
     VALUE vkey = (VALUE) key;
 
-    if ( rb_obj_is_kind_of(key, rb_cClass) == Qtrue ) {
-        rb_hash_aset((VALUE) hash_ptr, vkey, INT2NUM(value));
-    }
+    rb_hash_aset((VALUE) hash_ptr, vkey, INT2NUM(value));
 
     return ST_CONTINUE;
 }
@@ -71,19 +80,22 @@ static int each_count(st_data_t key, st_data_t value, st_data_t hash_ptr) {
  * The returned Hash contains its own copy of the statistics, any further object
  * allocations/frees will not modify said Hash.
  *
+ * This method ignores singleton classes.
+ *
  * call-seq:
  *     Allocations.to_hash -> Hash
  */
 VALUE allocations_to_hash(VALUE self) {
+    AllocationState *state = allocation_state_get_struct(state_const);
+
     st_table *local_counts;
     VALUE hash;
 
-    if ( !object_counts ) {
+    if ( !state->object_counts ) {
         return rb_hash_new();
     }
 
-    local_counts = st_copy(object_counts);
-
+    local_counts = allocation_state_copy_table(state);
     hash = rb_hash_new();
 
     st_foreach(local_counts, each_count, (st_data_t) hash);
@@ -100,11 +112,13 @@ VALUE allocations_to_hash(VALUE self) {
  *     Allocations.start -> nil
  */
 VALUE allocations_start(VALUE self) {
+    AllocationState *state = allocation_state_get_struct(state_const);
+
     if ( rb_ivar_get(self, id_enabled) == Qtrue ) {
         return Qnil;
     }
 
-    object_counts = st_init_numtable();
+    allocation_state_allocate_counts(state);
 
     rb_ivar_set(self, id_enabled, Qtrue);
 
@@ -121,6 +135,8 @@ VALUE allocations_start(VALUE self) {
  *     Allocations.stop -> nil
  */
 VALUE allocations_stop(VALUE self) {
+    AllocationState *state = allocation_state_get_struct(state_const);
+
     if ( rb_ivar_get(self, id_enabled) != Qtrue ) {
         return Qnil;
     }
@@ -128,11 +144,7 @@ VALUE allocations_stop(VALUE self) {
     rb_tracepoint_disable(allocation_tracer);
     rb_tracepoint_disable(free_tracer);
 
-    if ( object_counts ) {
-        st_free_table(object_counts);
-    }
-
-    object_counts = NULL;
+    allocation_state_reset_counts(state);
 
     rb_ivar_set(self, id_enabled, Qfalse);
 
@@ -173,4 +185,8 @@ void Init_liballocations() {
 
     rb_define_const(mAllocations, "ALLOCATION_TRACER", allocation_tracer);
     rb_define_const(mAllocations, "FREE_TRACER", free_tracer);
+
+    Init_allocations_state();
+
+    state_const = rb_const_get(mAllocations, rb_intern("STATE"));
 }

data/ext/liballocations/liballocations.h

@@ -5,6 +5,8 @@
 #include <ruby/debug.h>
 #include <ruby/st.h>
 
+#include "state.h"
+
 void Init_liballocations();
 
 #endif

data/ext/liballocations/state.c

@@ -0,0 +1,65 @@
+#include "state.h"
+
+static int mark_each_entry(st_data_t key, st_data_t value, st_data_t data) {
+    rb_gc_mark((VALUE) key);
+
+    return ST_CONTINUE;
+}
+
+// Initializes the table used for storing object counts.
+void allocation_state_allocate_counts(AllocationState *state) {
+    state->object_counts = st_init_numtable();
+}
+
+// Resets the table used for storing object counts.
+void allocation_state_reset_counts(AllocationState *state) {
+    if ( state->object_counts ) {
+        st_free_table(state->object_counts);
+    }
+
+    state->object_counts = NULL;
+}
+
+// Returns the AllocationState wrapped by `object`
+AllocationState *allocation_state_get_struct(VALUE object) {
+    AllocationState *state;
+
+    Data_Get_Struct(object, AllocationState, state);
+
+    return state;
+}
+
+st_table *allocation_state_copy_table(AllocationState *state) {
+    return st_copy(state->object_counts);
+}
+
+void allocation_state_mark(AllocationState *state) {
+    if ( state->object_counts ) {
+        st_foreach(state->object_counts, mark_each_entry, (st_data_t) NULL);
+    }
+}
+
+void allocation_state_free(AllocationState *state) {
+    allocation_state_reset_counts(state);
+
+    free(state);
+}
+
+VALUE allocation_state_allocate(VALUE klass) {
+    AllocationState *state = ALLOC(AllocationState);
+
+    state->object_counts = NULL;
+
+    return Data_Wrap_Struct(klass, allocation_state_mark, allocation_state_free,
+                            state);
+}
+
+void Init_allocations_state() {
+    VALUE mAllocations = rb_const_get(rb_cObject, rb_intern("Allocations"));
+    VALUE cState = rb_define_class_under(mAllocations, "State", rb_cObject);
+
+    rb_define_alloc_func(cState, allocation_state_allocate);
+
+    rb_define_const(mAllocations, "STATE",
+                    rb_funcall(cState, rb_intern("new"), 0));
+}

data/ext/liballocations/state.h

@@ -0,0 +1,17 @@
+#ifndef ALLOCATIONS_STATE_H
+#define ALLOCATIONS_STATE_H
+
+#include "liballocations.h"
+
+typedef struct {
+    st_table *object_counts;
+} AllocationState;
+
+extern void allocation_state_reset_counts(AllocationState*);
+extern void allocation_state_allocate_counts(AllocationState*);
+extern AllocationState *allocation_state_get_struct(VALUE object);
+extern st_table *allocation_state_copy_table(AllocationState*);
+
+extern void Init_allocations_state();
+
+#endif

data/lib/allocations/version.rb

@@ -1,3 +1,3 @@
 module Allocations
-  VERSION = '1.0.4'
+  VERSION = '1.0.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: allocations
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 1.0.5
 platform: ruby
 authors:
 - Yorick Peterse
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-15 00:00:00.000000000 Z
+date: 2016-06-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -79,6 +79,8 @@ files:
 - ext/liballocations/extconf.rb
 - ext/liballocations/liballocations.c
 - ext/liballocations/liballocations.h
+- ext/liballocations/state.c
+- ext/liballocations/state.h
 - lib/allocations.rb
 - lib/allocations/version.rb
 homepage: https://gitlab.com/gitlab-org/allocations