oj 3.13.3 → 3.13.4

data/ext/oj/cache.c

@@ -4,9 +4,14 @@
 #if HAVE_PTHREAD_MUTEX_INIT
 #include <pthread.h>
 #endif
+#include <stdlib.h>
 
 #include "cache.h"
 
+// The stdlib calloc, realloc, and free are used instead of the Ruby ALLOC,
+// ALLOC_N, REALLOC, and xfree since the later could trigger a GC which will
+// either corrupt memory or if the mark function locks will deadlock.
+
 #define REHASH_LIMIT 4
 #define MIN_SHIFT 8
 #define REUSE_MAX 8192
@@ -23,23 +28,23 @@
 #define M 0x5bd1e995
 
 typedef struct _slot {
-    struct _slot *next;
-    VALUE         val;
-    uint64_t      hash;
-    uint32_t      use_cnt;
-    uint8_t       klen;
-    char          key[CACHE_MAX_KEY];
+    struct _slot *    next;
+    VALUE             val;
+    uint64_t          hash;
+    volatile uint32_t use_cnt;
+    uint8_t           klen;
+    char              key[CACHE_MAX_KEY];
 } * Slot;
 
 typedef struct _cache {
-    Slot * slots;
-    size_t cnt;
+    volatile Slot * slots;
+    volatile size_t cnt;
     VALUE (*form)(const char *str, size_t len);
     uint64_t size;
     uint64_t mask;
     VALUE (*intern)(struct _cache *c, const char *key, size_t len);
-    Slot   reuse;
-    size_t rcnt;
+    volatile Slot reuse;
+    size_t        rcnt;
 #if HAVE_PTHREAD_MUTEX_INIT
     pthread_mutex_t mutex;
 #else
@@ -53,22 +58,6 @@ void cache_set_form(Cache c, VALUE (*form)(const char *str, size_t len)) {
     c->form = form;
 }
 
-#if 0
-// For debugging only.
-static void cache_print(Cache c) {
-    for (uint64_t i = 0; i < c->size; i++) {
-        printf("%4d:", i);
-        for (Slot s = c->slots[i]; NULL != s; s = s->next) {
-            char buf[40];
-            strncpy(buf, s->key, s->klen);
-            buf[s->klen] = '\0';
-            printf(" %s", buf);
-        }
-        printf("\n");
-    }
-}
-#endif
-
 static uint64_t hash_calc(const uint8_t *key, size_t len) {
     const uint8_t *end     = key + len;
     const uint8_t *endless = key + (len & 0xFFFFFFFC);
@@ -104,23 +93,24 @@ static uint64_t hash_calc(const uint8_t *key, size_t len) {
 }
 
 static void rehash(Cache c) {
-    uint64_t osize = c->size;
+    uint64_t osize;
     Slot *   end;
     Slot *   sp;
 
-    c->size = osize * 4;
-    c->mask = c->size - 1;
-    REALLOC_N(c->slots, Slot, c->size);
-    memset(c->slots + osize, 0, sizeof(Slot) * osize * 3);
-    end = c->slots + osize;
-    for (sp = c->slots; sp < end; sp++) {
+    osize    = c->size;
+    c->size  = osize * 4;
+    c->mask  = c->size - 1;
+    c->slots = realloc((void *)c->slots, sizeof(Slot) * c->size);
+    memset((Slot *)c->slots + osize, 0, sizeof(Slot) * osize * 3);
+    end = (Slot *)c->slots + osize;
+    for (sp = (Slot *)c->slots; sp < end; sp++) {
         Slot s    = *sp;
         Slot next = NULL;
 
         *sp = NULL;
         for (; NULL != s; s = next) {
             uint64_t h      = s->hash & c->mask;
-            Slot *   bucket = c->slots + h;
+            Slot *   bucket = (Slot *)c->slots + h;
 
             next    = s->next;
             s->next = *bucket;
@@ -130,14 +120,15 @@ static void rehash(Cache c) {
 }
 
 static VALUE lockless_intern(Cache c, const char *key, size_t len) {
-    uint64_t h      = hash_calc((const uint8_t *)key, len);
-    Slot *   bucket = c->slots + (h & c->mask);
-    Slot     b;
+    uint64_t       h      = hash_calc((const uint8_t *)key, len);
+    Slot *         bucket = (Slot *)c->slots + (h & c->mask);
+    Slot           b;
+    volatile VALUE rkey;
 
     while (REUSE_MAX < c->rcnt) {
         if (NULL != (b = c->reuse)) {
             c->reuse = b->next;
-            xfree(b);
+            free(b);
             c->rcnt--;
         } else {
             // An accounting error occured somewhere so correct it.
@@ -146,46 +137,44 @@ static VALUE lockless_intern(Cache c, const char *key, size_t len) {
     }
     for (b = *bucket; NULL != b; b = b->next) {
         if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
-            b->use_cnt += 4;
+            b->use_cnt += 16;
             return b->val;
         }
     }
-    {
-        volatile VALUE rkey = c->form(key, len);
-
-        if (NULL == (b = c->reuse)) {
-            b = ALLOC(struct _slot);
-        } else {
-            c->reuse = b->next;
-            c->rcnt--;
-        }
-        b->hash = h;
-        memcpy(b->key, key, len);
-        b->klen     = (uint8_t)len;
-        b->key[len] = '\0';
-        b->val      = rkey;
-        b->use_cnt  = 4;
-        b->next     = *bucket;
-        *bucket     = b;
-        c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
-        if (REHASH_LIMIT < c->cnt / c->size) {
-            rehash(c);
-        }
+    rkey = c->form(key, len);
+    if (NULL == (b = c->reuse)) {
+        b = calloc(1, sizeof(struct _slot));
+    } else {
+        c->reuse = b->next;
+        c->rcnt--;
+    }
+    b->hash = h;
+    memcpy(b->key, key, len);
+    b->klen     = (uint8_t)len;
+    b->key[len] = '\0';
+    b->val      = rkey;
+    b->use_cnt  = 4;
+    b->next     = *bucket;
+    *bucket     = b;
+    c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
+    if (REHASH_LIMIT < c->cnt / c->size) {
+        rehash(c);
     }
-    return b->val;
+    return rkey;
 }
 
 static VALUE locking_intern(Cache c, const char *key, size_t len) {
-    uint64_t h;
-    Slot *   bucket;
-    Slot     b;
-    uint64_t old_size;
+    uint64_t       h;
+    Slot *         bucket;
+    Slot           b;
+    uint64_t       old_size;
+    volatile VALUE rkey;
 
     CACHE_LOCK(c);
     while (REUSE_MAX < c->rcnt) {
         if (NULL != (b = c->reuse)) {
             c->reuse = b->next;
-            xfree(b);
+            free(b);
             c->rcnt--;
         } else {
             // An accounting error occured somewhere so correct it.
@@ -193,53 +182,53 @@ static VALUE locking_intern(Cache c, const char *key, size_t len) {
         }
     }
     h      = hash_calc((const uint8_t *)key, len);
-    bucket = c->slots + (h & c->mask);
+    bucket = (Slot *)c->slots + (h & c->mask);
     for (b = *bucket; NULL != b; b = b->next) {
         if ((uint8_t)len == b->klen && 0 == strncmp(b->key, key, len)) {
             b->use_cnt += 4;
             CACHE_UNLOCK(c);
+
             return b->val;
         }
     }
     old_size = c->size;
     // The creation of a new value may trigger a GC which be a problem if the
     // cache is locked so make sure it is unlocked for the key value creation.
-    if (NULL == (b = c->reuse)) {
-        b = ALLOC(struct _slot);
-    } else {
+    if (NULL != (b = c->reuse)) {
         c->reuse = b->next;
         c->rcnt--;
     }
     CACHE_UNLOCK(c);
-    {
-        volatile VALUE rkey = c->form(key, len);
-
-        b->hash = h;
-        memcpy(b->key, key, len);
-        b->klen     = (uint8_t)len;
-        b->key[len] = '\0';
-        b->val      = rkey;
-        b->use_cnt  = 4;
-
-        // Lock again to add the new entry.
-        CACHE_LOCK(c);
-        if (old_size != c->size) {
-            h      = hash_calc((const uint8_t *)key, len);
-            bucket = c->slots + (h & c->mask);
-        }
-        b->next = *bucket;
-        *bucket = b;
-        c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
-        if (REHASH_LIMIT < c->cnt / c->size) {
-            rehash(c);
-        }
-        CACHE_UNLOCK(c);
+    if (NULL == b) {
+        b = calloc(1, sizeof(struct _slot));
+    }
+    rkey    = c->form(key, len);
+    b->hash = h;
+    memcpy(b->key, key, len);
+    b->klen     = (uint8_t)len;
+    b->key[len] = '\0';
+    b->val      = rkey;
+    b->use_cnt  = 16;
+
+    // Lock again to add the new entry.
+    CACHE_LOCK(c);
+    if (old_size != c->size) {
+        h      = hash_calc((const uint8_t *)key, len);
+        bucket = (Slot *)c->slots + (h & c->mask);
+    }
+    b->next = *bucket;
+    *bucket = b;
+    c->cnt++;  // Don't worry about wrapping. Worse case is the entry is removed and recreated.
+    if (REHASH_LIMIT < c->cnt / c->size) {
+        rehash(c);
     }
-    return b->val;
+    CACHE_UNLOCK(c);
+
+    return rkey;
 }
 
 Cache cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool mark, bool locking) {
-    Cache c     = ALLOC(struct _cache);
+    Cache c     = calloc(1, sizeof(struct _cache));
     int   shift = 0;
 
     for (; REHASH_LIMIT < size; size /= 2, shift++) {
@@ -252,16 +241,12 @@ Cache cache_create(size_t size, VALUE (*form)(const char *str, size_t len), bool
 #else
     c->mutex = rb_mutex_new();
 #endif
-    c->size  = 1 << shift;
-    c->mask  = c->size - 1;
-    c->slots = ALLOC_N(Slot, c->size);
-    memset(c->slots, 0, sizeof(Slot) * c->size);
-    c->form  = form;
-    c->cnt   = 0;
-    c->xrate = 1;  // low
-    c->mark  = mark;
-    c->reuse = NULL;
-    c->rcnt  = 0;
+    c->size    = 1 << shift;
+    c->mask    = c->size - 1;
+    c->slots   = calloc(c->size, sizeof(Slot));
+    c->form    = form;
+    c->xrate   = 1;  // low
+    c->mark    = mark;
     if (locking) {
         c->intern = locking_intern;
     } else {
@@ -283,11 +268,11 @@ void cache_free(Cache c) {
 
         for (s = c->slots[i]; NULL != s; s = next) {
             next = s->next;
-            xfree(s);
+            free(s);
         }
     }
-    xfree(c->slots);
-    xfree(c);
+    free((void *)c->slots);
+    free(c);
 }
 
 void cache_mark(Cache c) {
@@ -334,7 +319,7 @@ void cache_mark(Cache c) {
 
 VALUE
 cache_intern(Cache c, const char *key, size_t len) {
-    if (CACHE_MAX_KEY < len) {
+    if (CACHE_MAX_KEY <= len) {
         return c->form(key, len);
     }
     return c->intern(c, key, len);

data/ext/oj/intern.c

@@ -51,7 +51,7 @@ static VALUE form_str(const char *str, size_t len) {
 }
 
 static VALUE form_sym(const char *str, size_t len) {
-    return rb_str_intern(rb_utf8_str_new(str, len));
+    return rb_to_symbol(rb_str_intern(rb_utf8_str_new(str, len)));
 }
 
 static VALUE form_attr(const char *str, size_t len) {
@@ -112,7 +112,14 @@ void oj_hash_init() {
 
 VALUE
 oj_str_intern(const char *key, size_t len) {
+    // For huge cache sizes over half a million the rb_enc_interned_str
+    // performs slightly better but at more "normal" size of a several
+    // thousands the cache intern performs about 20% better.
+#if HAVE_RB_ENC_INTERNED_STR && 0
+    return rb_enc_interned_str(key, len, rb_utf8_encoding());
+#else
     return cache_intern(str_cache, key, len);
+#endif
 }
 
 VALUE

data/ext/oj/oj.c

@@ -107,6 +107,7 @@ static VALUE bigdecimal_load_sym;
 static VALUE bigdecimal_sym;
 static VALUE cache_keys_sym;
 static VALUE cache_str_sym;
+static VALUE cache_string_sym;
 static VALUE circular_sym;
 static VALUE class_cache_sym;
 static VALUE compat_bigdecimal_sym;
@@ -287,7 +288,7 @@ struct _options oj_default_options = {
  * - *:ignore* [_nil_|_Array_] either nil or an Array of classes to ignore when dumping
  * - *:ignore_under* [_Boolean_] if true then attributes that start with _ are ignored when dumping in
  *object or custom mode.
- * - *:cache_keys* [_Boolean_] if true then hash keys are cached
+ * - *:cache_keys* [_Boolean_] if true then hash keys are cached if less than 35 bytes.
  * - *:cache_str* [_Fixnum_] maximum string value length to cache (strings less than this are cached)
  * - *:integer_range* [_Range_] Dump integers outside range as strings.
  * - *:trace* [_true,_|_false_] Trace all load and dump calls, default is false (trace is off)
@@ -692,7 +693,7 @@ static int parse_options_cb(VALUE k, VALUE v, VALUE opts)
             sprintf(copts->float_fmt, "%%0.%dg", n);
             copts->float_prec = n;
         }
-    } else if (cache_str_sym == k) {
+    } else if (cache_str_sym == k || cache_string_sym == k) {
         int n;
 
 #ifdef RUBY_INTEGER_UNIFICATION
@@ -1920,6 +1921,8 @@ void Init_oj() {
     rb_gc_register_address(&cache_keys_sym);
     cache_str_sym = ID2SYM(rb_intern("cache_str"));
     rb_gc_register_address(&cache_str_sym);
+    cache_string_sym = ID2SYM(rb_intern("cache_string"));
+    rb_gc_register_address(&cache_string_sym);
     circular_sym = ID2SYM(rb_intern("circular"));
     rb_gc_register_address(&circular_sym);
     class_cache_sym = ID2SYM(rb_intern("class_cache"));

data/lib/oj/version.rb

@@ -1,5 +1,5 @@
 
 module Oj
   # Current version of the module.
-  VERSION = '3.13.3'
+  VERSION = '3.13.4'
 end

data/pages/Options.md

@@ -75,12 +75,22 @@ parse option to match the JSON gem. In that case either `Float`,
 If true Hash keys are cached or interned. There are trade-offs with
 caching keys. Large caches will use more memory and in extreme cases
 (like over a million) the cache may be slower than not using
-it. Repeated parsing of similar JSON docs is where cache_keys shines.
+it. Repeated parsing of similar JSON docs is where cache_keys shines
+especially with symbol keys.
+
+There is a maximum length for cached keys. Any key longer than 34
+bytes is not cached. Everything still works but the key is not cached.
 
 ### :cache_strings [Int]
 
 Shorter strings can be cached for better performance. A limit,
-cache_strings, defines the upper limit on what strings are cached.
+cache_strings, defines the upper limit on what strings are cached. As
+with cached keys only strings less than 35 bytes are cached even if
+the limit is set higher. Setting the limit to zero effectively
+disables the caching of string values.
+
+Note that caching for strings is for string values and not Hash keys
+or Object attributes.
 
 ### :circular [Boolean]
 

data/test/benny.rb

@@ -0,0 +1,50 @@
+#!/usr/bin/env ruby
+# frozen_string_literal
+
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+
+  gem 'oj'
+  gem 'benchmark-ips', require: 'benchmark/ips'
+end
+
+require 'json'
+require 'open-uri'
+
+CANADA_DATA_JSON = URI.parse('https://raw.githubusercontent.com/serde-rs/json-benchmark/master/data/canada.json').read
+CANADA_DATA = JSON.parse(CANADA_DATA_JSON)
+
+Benchmark.ips do |x|
+  x.config(:time => 10, :warmup => 5)
+
+  x.report("marshall Canada data with Oj") do
+    Oj.dump(CANADA_DATA)
+  end
+
+  x.report("marshall Canada data with JSON") do
+    JSON.dump(CANADA_DATA)
+  end
+
+  x.compare!
+end
+
+Oj.default_options = {
+  mode: :strict,
+  bigdecimal_load: :fast
+}
+
+Benchmark.ips do |x|
+  x.config(:time => 10, :warmup => 5)
+
+  x.report("unmarshall Canada data with Oj") do
+    Oj.load(CANADA_DATA_JSON)
+  end
+
+  x.report("unmarshall Canada data with JSON") do
+    JSON.parse(CANADA_DATA_JSON)
+  end
+
+  x.compare!
+end