hash_unnest 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: c988aea31df14ef50afcaf73818f844a0ab61aca55fcf0614425a95441a6e810
-  data.tar.gz: 0f47f4110f2ee9a2ba2bd1133d8d55ec0c7c44135b569abc3efae44f6a18790f
+SHA1:
+  metadata.gz: 3bcf3dbb4e02471f88372a12cf1908cb623b1c98
+  data.tar.gz: 11f945786febf21b933472abc145e2399bc950b1
 SHA512:
-  metadata.gz: d75dfe4e4d93a2ba794d0b0d4cfac7120aca446372063af6e012dee0ffcfcfd6a8ece663394359d4b273dac3ef74f7f039ac0a4b28d80767fa0c1264047b3bac
-  data.tar.gz: 98252c49b5744768268406c302441eb3654daf8c120cfb9d8ad605df97d22176591a20000616ec46afca8b933517a17bbcf565f15c90cdc5719a16af35438dc6
+  metadata.gz: ea4c0c8e5b46c13a33c482d6601f1a3e59132f4a061b6f9e3249db98b862c096fd813e3b6992bdf134f3d123faf1be6bb185030c3f6b6860a4cecf473f16cb15
+  data.tar.gz: 3368483ac0fe6f3247d8050b37eb114571573cd57bde99c16e174b096cf696eb57af470d7edf08b9b50ab28509ae5a1a6c0d25ec74f761b396ad5cc9033030cc

data/ext/hash_unnest/extconf.rb

@@ -4,9 +4,10 @@ PLATFORM = `uname`.strip.upcase
 SHARED_FLAGS = "--std=c99 -Wall -Wextra -Werror"
 
 # production
-$CFLAGS += " #{SHARED_FLAGS} -Os"
+$CFLAGS += " #{SHARED_FLAGS} -Os -g"
 
 # development
 # $CFLAGS += " #{SHARED_FLAGS} -O0 -g -DDEBUG"
+# $CFLAGS += " #{SHARED_FLAGS} -Os -g"
 
 create_makefile('hash_unnest/hash_unnest')

data/ext/hash_unnest/hash_unnest.c

@@ -2,17 +2,90 @@
 #include <assert.h>
 #include "hash_unnest.h"
 
+#define RECORD_MAGIC 0xF00DF00D
+#define BUFFER_MAGIC 0xBA0BAB00
+
 // forward declarataions of closures
-static int hash_unnest_size_closure(VALUE key, VALUE val, VALUE in);
-static int hash_unnest_closure(VALUE key, VALUE val, VALUE in);
+static int hn_size_closure(VALUE key, VALUE val, VALUE in);
+static int hn_unnest_closure(VALUE key, VALUE val, VALUE in);
+
+static VALUE hn_hash_unnest_m = Qnil;
 
-static VALUE eHashUnnestModule = Qnil;
+static VALUE hn_buffer_type = Qnil;
+static VALUE hn_int_type = Qnil;
 
 // a (sortable) key-value entry
 typedef struct {
+  #ifndef NDEBUG
+    unsigned int magic;
+  #endif
   VALUE key;
   VALUE value;
-} hn_record_t;
+} hn_entry_t;
+
+// a safe C array of key, value pairs
+typedef struct {
+  #ifndef NDEBUG
+    unsigned int magic;
+  #endif
+  int size;
+  int cursor;
+  hn_entry_t* buf;
+} hn_buffer_t;
+
+/******************************************************************************/
+
+static void hn_buffer_free(hn_buffer_t* buf) {
+  LOG("*** hn_buffer_free\n");
+
+  xfree(buf->buf);
+  buf->buf = NULL;
+  #ifndef NDEBUG
+    buf->magic = 0;
+  #endif
+  xfree(buf);
+}
+
+static void hn_buffer_mark(hn_buffer_t* buf) {
+  LOG("*** hn_buffer_mark\n");
+
+  assert(buf->magic == BUFFER_MAGIC);
+
+  for (int k = 0; k < buf->cursor; ++k) {
+    LOG("  rb_gc_mark '%s'\n", StringValueCStr(buf->buf[k].key));
+    rb_gc_mark(buf->buf[k].key);
+    rb_gc_mark(buf->buf[k].value);
+  }
+}
+
+static VALUE hn_buffer_alloc(int size) {
+  hn_buffer_t* buf = NULL;
+
+  buf = ALLOC(hn_buffer_t);
+  #ifndef NDEBUG
+    buf->magic = BUFFER_MAGIC;
+  #endif
+  buf->buf   = ALLOC_N(hn_entry_t, size+1);
+  buf->size  = size;
+  buf->cursor = 0;
+
+  for (int k = 0; k < size; ++k) {
+    #ifndef NDEBUG
+      buf->buf[k].magic = RECORD_MAGIC;
+    #endif
+    buf->buf[k].key = Qnil;
+    buf->buf[k].value = Qnil;
+  }
+
+  // sentinel entry
+  #ifndef NDEBUG
+    buf->buf[size].magic = 0;
+  #endif
+  buf->buf[size].key   = Qnil;
+  buf->buf[size].value = Qnil;
+
+  return Data_Wrap_Struct(hn_buffer_type, hn_buffer_mark, hn_buffer_free, buf);
+}
 
 /******************************************************************************/
 
@@ -27,17 +100,17 @@ typedef struct {
 // - When `val` is a hash, call ourselves recursively, appending the
 //   current key to the prefix.
 //
-static int hash_unnest_closure(VALUE key, VALUE val, VALUE in)
+static int hn_unnest_closure(VALUE key, VALUE val, VALUE in)
 {
   VALUE prefix = rb_ary_entry(in, 0);
-  hn_record_t** output = (hn_record_t**) rb_ary_entry(in, 1);
 
 #ifdef DEBUG
   VALUE _str_key = rb_funcall(key,    rb_intern("inspect"), 0);
   VALUE _str_val = rb_funcall(val,    rb_intern("inspect"), 0);
-  LOG("*** hash_unnest_closure (%s,%s,'%s')\n", StringValueCStr(_str_key), StringValueCStr(_str_val), StringValueCStr(prefix));
+  LOG("*** hn_unnest_closure (%s,%s,'%s')\n", StringValueCStr(_str_key), StringValueCStr(_str_val), StringValueCStr(prefix));
 #endif
 
+
   switch(TYPE(val)) {
     case T_HASH:
       {
@@ -50,19 +123,34 @@ static int hash_unnest_closure(VALUE key, VALUE val, VALUE in)
 
         new_in = rb_ary_new2(2);
         rb_ary_store(new_in, 0, new_prefix);
-        rb_ary_store(new_in, 1, (VALUE) output);
+        rb_ary_store(new_in, 1, rb_ary_entry(in, 1));
 
-        rb_hash_foreach(val, hash_unnest_closure, new_in);
+        rb_hash_foreach(val, hn_unnest_closure, new_in);
         break;
       }
     default:
       {
         VALUE new_key = rb_str_dup(prefix);
+        hn_buffer_t* c_buf;
 
         rb_str_append(new_key, key);
-        (*output)->key   = new_key;
-        (*output)->value = val;
-        *output = *output + 1;
+        Data_Get_Struct(rb_ary_entry(in, 1), hn_buffer_t, c_buf);
+
+        #ifdef DEBUG
+          {
+            VALUE _str_key = rb_funcall(new_key, rb_intern("inspect"), 0);
+            VALUE _str_val = rb_funcall(val,     rb_intern("inspect"), 0);
+            LOG("  adding item %d: %s, %s\n", c_buf->cursor, StringValueCStr(_str_key), StringValueCStr(_str_val));
+          }
+        #endif
+
+        assert(c_buf->magic == BUFFER_MAGIC);
+        assert(c_buf->cursor >= 0);
+        assert(c_buf->cursor < c_buf->size);
+        assert(c_buf->buf[c_buf->cursor].magic == RECORD_MAGIC);
+        c_buf->buf[c_buf->cursor].key   = new_key;
+        c_buf->buf[c_buf->cursor].value = val;
+        ++(c_buf->cursor);
       }
   }
   return ST_CONTINUE;
@@ -71,17 +159,18 @@ static int hash_unnest_closure(VALUE key, VALUE val, VALUE in)
 /******************************************************************************/
 
 // Recursively counts the number of leaves ("size") of a nested hash.
-static int hash_unnest_size_closure(VALUE key, VALUE val, VALUE in)
+static int hn_size_closure(VALUE key, VALUE val, VALUE in)
 {
+  int* size = NULL;
   switch(TYPE(val)) {
     case T_HASH:
       {
-        rb_hash_foreach(val, hash_unnest_size_closure, in);
+        rb_hash_foreach(val, hn_size_closure, in);
         break;
       }
     default:
       {
-        int* size = (int*) in;
+        Data_Get_Struct(in, int, size);
         *size = *size + 1;
       }
   }
@@ -90,10 +179,10 @@ static int hash_unnest_size_closure(VALUE key, VALUE val, VALUE in)
 
 /******************************************************************************/
 
-// Compares the `key`s in `hn_record_t`s, for sorting purposes.
-int hn_record_compare(const void* a, const void* b) {
-  hn_record_t* record_a = (hn_record_t*) a;
-  hn_record_t* record_b = (hn_record_t*) b;
+/* Compares the `key`s in `hn_entry_t`s, for sorting purposes. */
+int hn_entry_compare(const void* a, const void* b) {
+  hn_entry_t* record_a = (hn_entry_t*) a;
+  hn_entry_t* record_b = (hn_entry_t*) b;
 
   LOG("compare '%s' to '%s'\n", StringValueCStr(record_a->key), StringValueCStr(record_b->key));
 
@@ -106,21 +195,26 @@ int hn_record_compare(const void* a, const void* b) {
 
 /******************************************************************************/
 
-static VALUE hash_unnest_unnest(VALUE self)
+static VALUE hn_unnest(VALUE self)
 {
-  VALUE result, in, prefix;
-  hn_record_t* buf;
-  hn_record_t* buf_ptr;
+  VALUE result, in, buf, prefix;
+  hn_buffer_t* c_buf = NULL;
   int size = 0;
 
 #ifdef DEBUG
   {
     VALUE _str_self   = rb_funcall(self,   rb_intern("to_s"), 0);
-    LOG("*** hash_unnest_unnest (%s)\n", StringValueCStr(_str_self));
+    LOG("*** hn_unnest (%s)\n", StringValueCStr(_str_self));
   }
 #endif
 
-  rb_hash_foreach(self, hash_unnest_size_closure, (VALUE) &size);
+  // count leaves in input
+  rb_hash_foreach(
+      self,
+      hn_size_closure,
+      Data_Wrap_Struct(hn_int_type, NULL, NULL, &size)
+  );
+
 #ifdef DEBUG
   {
     VALUE _str_self   = rb_funcall(self,   rb_intern("to_s"), 0);
@@ -128,28 +222,37 @@ static VALUE hash_unnest_unnest(VALUE self)
   }
 #endif
 
-  buf = (hn_record_t*) malloc(size * sizeof(hn_record_t));
-  buf_ptr = buf;
-
+  // unnest `self` into `buf`
   prefix = rb_str_new("", 0);
+  buf = hn_buffer_alloc(size);
 
   in = rb_ary_new2(2);
   rb_ary_store(in, 0, prefix);
-  rb_ary_store(in, 1, (VALUE) &buf_ptr);
-    
-  rb_hash_foreach(self, hash_unnest_closure, in);
+  rb_ary_store(in, 1, buf);
+  
+  rb_hash_foreach(self, hn_unnest_closure, in);
 
-  qsort((void*) buf, size, sizeof(hn_record_t), hn_record_compare);
+  // sort the C array of key, value pairs
+  Data_Get_Struct(buf, hn_buffer_t, c_buf);
+  assert(c_buf != NULL);
+  assert(c_buf->buf != NULL);
+  assert(c_buf->magic == BUFFER_MAGIC);
+  assert(c_buf->cursor == size);
 
+  qsort((void*) c_buf->buf, c_buf->cursor, sizeof(hn_entry_t), hn_entry_compare);
+
+  // copy the array into a new hash
   result = rb_hash_new();
-  for (int k = 0; k < size; ++k) {
-    hn_record_t entry = buf[k];
 
+  for (int k = 0; k < c_buf->cursor; ++k) {
+    hn_entry_t entry = c_buf->buf[k];
+
+    assert(entry.magic == RECORD_MAGIC);
+    assert(entry.key != Qnil);
+    assert(entry.value != Qnil);
     rb_hash_aset(result, entry.key, entry.value);
   }
 
-  free(buf);
-
   return result;
 }
 
@@ -158,10 +261,17 @@ static VALUE hash_unnest_unnest(VALUE self)
 void Init_hash_unnest(void) {
   LOG("*** Init_hash_unnest\n");
 
+  LOG("sizeof(VALUE) = %lu\n", sizeof(VALUE));
+  LOG("sizeof(int*)  = %lu\n", sizeof(int*));
+  assert(sizeof(VALUE) == sizeof(int*));
+
   /* assume we haven't yet defined hash_unnest */
-  eHashUnnestModule = rb_define_module("HashUnnest");
-  assert(eHashUnnestModule != Qnil);
+  hn_hash_unnest_m = rb_define_module("HashUnnest");
+  hn_buffer_type = rb_define_class_under(hn_hash_unnest_m, "CHnBuf", rb_cObject);
+  hn_int_type = rb_define_class_under(hn_hash_unnest_m, "CInt", rb_cObject);
+
+  assert(hn_hash_unnest_m != Qnil);
 
-  rb_define_method(eHashUnnestModule, "unnest_c", hash_unnest_unnest, 0);
+  rb_define_method(hn_hash_unnest_m, "unnest_c", hn_unnest, 0);
   return;
 }

data/lib/hash_unnest/version.rb

@@ -1,4 +1,4 @@
 module HashUnnest
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.0.1'.freeze
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hash_unnest
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Julien Letessier
@@ -100,7 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Fast hash unnesting