sereal 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e9c00595b7b2a08fc9b2357c3b052ff8a189f2e4
-  data.tar.gz: baac3f20a92210853ee70a77472343509a025fb5
+  metadata.gz: 64ff27261d48f5ecf93ef19adb89cd126590c397
+  data.tar.gz: c2a9ecfb806d3dd559bc0b18e9aea7b26128c44a
 SHA512:
-  metadata.gz: f9c467d56b2ee8386059b5799da6d40f3aa4dffdb81025ebdc02325593478f34b4ae08ea41a6498a0fb61f680645ef1c8b3e2f2f292158b1a818bb3434c25c72
-  data.tar.gz: 85e7ed8c617e392617fa6adbf78bc04e7e758eb20e964a6e452eeff81045eb3dff2601b73a0c61548ea91e0fbae3df7ef8ad0bd87d0abcb383739880f32cf5e3
+  metadata.gz: 02e40c40cb0a9f151ff59fa257037986519fadd6c68d6733db37c35fe41cd72b0b5b7958317e8732c40a24cc6df9bb0af8a9f1c12442d379eaabc486c6c2203a
+  data.tar.gz: edfc06b878c2516420f7358cba6ea478b053ae5b0c1dad802e6634eccd96dc0dfaab6726060ea1b8721621f4275537a3a77ea320b636893f954a1a81922dc715

data/bin/rsrl

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
-require 'pp'
 
+# encoding: UTF-8
+require 'pp'
 begin
   require File.join(".",File.dirname(__FILE__),'..','lib','sereal')
 rescue LoadError

data/ext/sereal/buffer.h

@@ -1,6 +1,5 @@
 #include "sereal.h"
 #include <errno.h>
-static void s_dump(sereal_t *s);
 
 static inline void s_free_data_if_not_mine(sereal_t *s) {
     if (!(s->flags & __NOT_MINE)) {
@@ -47,7 +46,7 @@ static inline void s_destroy(sereal_t *s) {
 
 static inline void *s_realloc_or_raise(sereal_t *s, void *p, u32 n) {
     u8 *buf = realloc(p,n);
-    if (!buf)
+    if (unlikely(!buf))
         s_raise(s,rb_eNoMemError,"memory allocation failure for %d bytes",n);
     return buf;
 }
@@ -66,15 +65,17 @@ static inline sereal_t * s_create(void) {
 }
 
 static inline void s_alloc(sereal_t *s, u32 len) {
-    if (s->rsize > s->size + len)
+    if (likely(s->rsize > s->size + len))
         return;
 
-    u32 size = s->size + len + 512; // every time allocate 512b more, so we wont alloc for a while
+    u32 size = s->size + len + 10240; // every time allocate 10k more, so we wont alloc for a while
     u8 *buf = s_realloc_or_raise(s,s->data,size); 
     s->data = buf;
     s->rsize = size;
 }
-
+static inline void s_prepare(sereal_t *s, u32 s_len) {
+    s_alloc(s,s_len);
+}
 static inline void s_append(sereal_t *s, void *suffix, u32 s_len) {
     s_alloc(s,s_len);
     COPY(suffix,(s->data + s->size), s_len);
@@ -96,12 +97,12 @@ static inline int s_read_stream(sereal_t *s, u32 end) {
         u32 req = end - s->size;
         u32 left = s->buffer.size - s->buffer.pos;
         if (left == 0) {
-            int rc = read(s->fd,s->buffer.data,BUFSIZ);
+            size_t rc = read(s->fd,s->buffer.data,BUFSIZ);
             if (rc <= 0)
                 return -1;
-            s->buffer.size = rc;
+            s->buffer.size = (u32) rc;
             s->buffer.pos = 0;
-            left = rc;
+            left = (u32) rc;
         }
         left = left > req ? req : left;
         s_append(s,s->buffer.data + s->buffer.pos,left);
@@ -113,8 +114,8 @@ static inline int s_read_stream(sereal_t *s, u32 end) {
 
 static inline void *s_get_p_at_pos(sereal_t *s, u32 pos,u32 req) {
     // returning s->data[pos], so we just make size count from 0
-    if (pos + req >= s->size) {
-        if (s->flags & __STREAM) {
+    if (unlikely(pos + req >= s->size)) {
+        if (unlikely(s->flags & __STREAM)) {
             if (s_read_stream(s,pos + req + 1) < 0) {
                 s_raise(s,rb_eRangeError,"stream request for %d bytes failed (err: %s)",
                         req,strerror(errno));
@@ -191,7 +192,7 @@ static inline void s_set_flag_at_pos(sereal_t *s, u32 pos, u8 flag) {
 }
 
 static void b_dump(u8 *p, u32 len, u32 pos) {
-    int i;
+    u32 i;
 
     fprintf(stderr,"\n-----------\n");
     for (i = 0; i < len; i++) {

data/ext/sereal/decode.c

@@ -107,7 +107,7 @@ static VALUE s_read_rb_string_bang(sereal_t *s,u8 t) {
 // len - 1: we also use the current byte, similar to u32,float.. casts
 #define RETURN_STRING(fx_l,fx_gen)              \
     do {                                        \
-        len       = fx_l;                       \
+        len       = (u32) fx_l;                 \
         char *ptr = (char *) (len == 0 ? 0 : s_get_p_req_inclusive(s,len)); \
         string    = fx_gen;                     \
         s_shift_position_bang(s,len);           \
@@ -186,7 +186,7 @@ static VALUE s_read_ref(sereal_t *s, u8 tag) {
 
 #define TRAVEL(s,__stored)                                              \
     do {                                                                \
-        u32 offset = s_get_varint_bang(s) - 1;                          \
+        u32 offset = ((u32) s_get_varint_bang(s)) - 1;                  \
         __stored = s->pos;                                              \
         s->pos = offset + s->hdr_end;                                   \
         SD(s,"going back offset: %d, stored position: %d (tag: %d) new pos: %d",offset,stored_pos,tag,s->pos); \
@@ -272,7 +272,7 @@ VALUE sereal_to_rb_object(sereal_t *s) {
 
         VALUE decoded = (*READERS[t])(s,t);
 
-        if (tracked) {
+        if (unlikely(tracked)) {
             s_init_tracker(s);
             SD(s,"tracking object of class: %s(id: %d) at position: %d",rb_obj_classname(decoded),FIX2INT(rb_obj_id(decoded)),pos);
             VALUE v_pos = INT2FIX(pos);
@@ -346,8 +346,8 @@ again:
     }
 
     u32 magic = s_get_u32_bang(s);
-    if (magic != SRL_MAGIC_STRING_UINT_LE)
-        s_raise(s,rb_eTypeError,"invalid header: %d (%x)",magic,magic);
+    if (magic != SRL_MAGIC_STRING_UINT_LE && magic != SRL_MAGIC_STRING_UINT_LE_HB)
+        s_raise(s,rb_eTypeError,"invalid header: %d (%x) vs %x",magic,magic,SRL_MAGIC_STRING_UINT_LE);
 
     u8 version = s_get_u8_bang(s);
     u8 suffix = s_get_varint_bang(s);

data/ext/sereal/decode.h

@@ -13,9 +13,7 @@ static VALUE s_read_hash(sereal_t *s, u8 tag);
 static VALUE s_read_hashref(sereal_t *s, u8 tag);
 static VALUE s_read_rb_string_bang(sereal_t *s,u8 t);
 static VALUE s_read_next_rb_string_bang(sereal_t *s);
-static VALUE s_read_object(sereal_t *s,u8 tag);
 static VALUE s_read_regexp(sereal_t *s, u8 tag);
-static VALUE s_read_sym(sereal_t *s,u8 tag);
 static VALUE s_read_nil(sereal_t *s, u8 tag);
 static VALUE s_read_true(sereal_t *s, u8 tag);
 static VALUE s_read_false(sereal_t *s, u8 tag);

data/ext/sereal/encode.c

@@ -45,8 +45,7 @@ static void rb_object_to_sereal(sereal_t *s, VALUE object);
 static void s_append_varint(sereal_t *s,u64 n);
 static void s_append_hdr_with_varint(sereal_t *s,u8 hdr, u64 n);
 static void s_append_zigzag(sereal_t *s,long long n);
-static void s_append_string(sereal_t *s,u8 *string, u32 len,u8 is_utf8);
-static void s_append_rb_string(sereal_t *s, VALUE object);
+static void s_append_string(sereal_t *s, VALUE object);
 static void s_append_array(sereal_t *s, VALUE object);
 static void s_append_hash(sereal_t *s, VALUE object);
 static void s_append_symbol(sereal_t *s, VALUE object);
@@ -70,7 +69,7 @@ void s_init_writers(void) {
     WRITER[T_FLOAT]  = s_append_double;
     WRITER[T_OBJECT] = s_append_object;
     WRITER[T_REGEXP] = s_append_regexp;
-    WRITER[T_STRING] = s_append_rb_string;
+    WRITER[T_STRING] = s_append_string;
     WRITER[T_ARRAY]  = s_append_array;
     WRITER[T_HASH]   = s_append_hash;
     WRITER[T_SYMBOL] = s_append_symbol;
@@ -84,13 +83,14 @@ static void s_default_writer(sereal_t *s, VALUE object) {
     s_raise(s,rb_eTypeError, "invalid type for input %s",rb_obj_classname(object));
 }
 
-
 static inline void s_append_varint(sereal_t *s,u64 n) {
-    while (n >= 0x80) {
-        s_append_u8(s,((n & 0x7f) | 0x80));
-        n >>= 7; 
+    s_prepare(s,SRL_MAX_VARINT_LENGTH+1);
+    while (likely(n >= 0x80)) {
+        s->data[s->size++] = (n & 0x7f) | 0x80;
+        n = n >> 7;
     }
-    s_append_u8(s,n);
+    s->data[s->size++] = n;
+    s->pos = s->size;
 }
 
 static inline void s_append_hdr_with_varint(sereal_t *s,u8 hdr, u64 n) {
@@ -102,28 +102,23 @@ static inline void s_append_zigzag(sereal_t *s,long long n) {
     s_append_hdr_with_varint(s,SRL_HDR_ZIGZAG,(n << 1) ^ (n >> 63));
 }
 
-static inline void s_append_string(sereal_t *s,u8 *string, u32 len,u8 is_utf8) {
-    if (is_utf8) {
-        s_append_hdr_with_varint(s,SRL_HDR_STR_UTF8,len);
-    } else {
-        if (len < SRL_MASK_SHORT_BINARY_LEN) {
+static void s_append_string(sereal_t *s, VALUE object) {
+    u32 len = (u32) RSTRING_LEN(object);
+    if (likely(is_ascii_string(object))) {
+        if (likely(len < SRL_MASK_SHORT_BINARY_LEN)) {
             s_append_u8(s,SRL_HDR_SHORT_BINARY_LOW | (u8)len);
         } else {
             s_append_hdr_with_varint(s,SRL_HDR_BINARY,len); 
         }
+    } else {
+        s_append_hdr_with_varint(s,SRL_HDR_STR_UTF8,len);
     }
-    s_append(s,string,len);
-}
-
-static void s_append_rb_string(sereal_t *s, VALUE object) {
-    s_append_string(s,(u8 *)RSTRING_PTR(object),
-                    RSTRING_LEN(object),
-                    (is_ascii_string(object) ? FALSE : TRUE));
+    s_append(s,(u8 *)RSTRING_PTR(object),len);
 }
 
 #define REF_THRESH(thresh,low,high)                     \
     do {                                                \
-        if (len < (thresh))                             \
+        if (unlikely(len < (thresh)))                   \
             s_append_u8(s, low | (u8) len);             \
         else                                            \
             s_append_hdr_with_varint(s,high,len);       \
@@ -139,7 +134,7 @@ static void s_append_array(sereal_t *s, VALUE object) {
 
 
 int s_hash_foreach(VALUE key, VALUE value, VALUE sereal_t_object) {
-    if (key == Qundef)
+    if (unlikely(key == Qundef))
         return ST_CONTINUE;
     rb_object_to_sereal((sereal_t *) sereal_t_object,key);
     rb_object_to_sereal((sereal_t *) sereal_t_object,value);
@@ -156,8 +151,7 @@ static void s_append_hash(sereal_t *s, VALUE object) {
 	convert symbols to strings
 */
 static void s_append_symbol(sereal_t *s, VALUE object) {
-    VALUE string = rb_sym_to_s(object);
-    s_append_rb_string(s,string);
+    s_append_string(s,rb_sym_to_s(object));
 }
 
 static void s_append_copy(sereal_t *s, u8 tag,VALUE object) {
@@ -166,11 +160,11 @@ static void s_append_copy(sereal_t *s, u8 tag,VALUE object) {
 }
 
 static VALUE s_copy_or_keep_in_mind(sereal_t *s, VALUE object, u8 offset) {
-    if (s->copy == Qnil)
+    if (likely(s->copy == Qnil))
         return Qnil;
 
     VALUE stored_position = rb_hash_lookup(s->copy,object);
-    if (stored_position == Qnil)
+    if (unlikely(stored_position == Qnil))
         rb_hash_aset(s->copy,object,INT2FIX(s->pos + offset));
     return stored_position;
 }
@@ -193,7 +187,7 @@ static void s_append_object(sereal_t *s, VALUE object) {
             s_append_copy(s,SRL_HDR_OBJECTV_FREEZE,copy);
         } else {
             s_append_u8(s,SRL_HDR_OBJECT_FREEZE);
-            s_append_rb_string(s,klass);
+            s_append_string(s,klass);
         }
         VALUE frozen = rb_funcall(object,FREEZE,1,ID2SYM(SEREAL));
         if (TYPE(frozen) != T_ARRAY)
@@ -223,7 +217,7 @@ static void s_append_regexp(sereal_t *s, VALUE object) {
 #else
     pattern = rb_enc_str_new(RREGEXP_SRC_PTR(object),RREGEXP_SRC_LEN(object), enc);
 #endif
-    s_append_rb_string(s,pattern);
+    s_append_string(s,pattern);
 
     int flags = rb_reg_options(object);
     VALUE f = rb_str_new("",0);
@@ -233,18 +227,18 @@ static void s_append_regexp(sereal_t *s, VALUE object) {
         rb_str_cat(f,"x",1);
     if (flags & MULTILINE)
         rb_str_cat(f,"m",1);
-    s_append_rb_string(s,f);
+    s_append_string(s,f);
 }
 
 #define I_APPEND(_v)                                                    \
     do {                                                                \
-        if (_v >= 0) {                                                  \
-            if (_v < 16)                                                \
+    if (likely(_v >= 0)) {                                              \
+            if (unlikely(_v < 16))                                      \
                 s_append_u8(s,SRL_HDR_POS_LOW | (u8) _v);               \
             else                                                        \
-                s_append_hdr_with_varint(s,SRL_HDR_VARINT,_v);          \
+                s_append_hdr_with_varint(s,SRL_HDR_VARINT,(u64)_v);     \
         } else {                                                        \
-            if (_v > -17)                                               \
+            if (unlikely(_v > -17))                                     \
                 s_append_u8(s,SRL_HDR_NEG_LOW | ((u8) _v + 32));        \
             else                                                        \
                 s_append_zigzag(s,_v);                                  \
@@ -252,12 +246,12 @@ static void s_append_regexp(sereal_t *s, VALUE object) {
     } while(0)
 
 static void s_append_fixnum(sereal_t *s, VALUE object) {
-    long long v = FIXNUM_P(object) ? FIX2LONG(object) : NUM2LL(object);
+    long long v = likely(FIXNUM_P(object)) ? FIX2LONG(object) : NUM2LL(object);
     I_APPEND(v);
 }
 
 static void s_append_bignum(sereal_t *s, VALUE object) {
-    if (RBIGNUM_POSITIVE_P(object)) {
+    if (likely(RBIGNUM_POSITIVE_P(object))) {
         unsigned long long uv = rb_big2ull(object);
         I_APPEND(uv);
     } else {
@@ -292,7 +286,7 @@ static void s_append_refp(sereal_t *s, VALUE object) {
 static void rb_object_to_sereal(sereal_t *s, VALUE object) {
     S_RECURSE_INC(s);
     u32 pos = s->pos;
-    if (COMPLEX(object)) {
+    if (unlikely(s->tracked != Qnil || s->copy != Qnil) && likely(COMPLEX(object))) {
         VALUE stored;
         if (s->tracked != Qnil) {
             VALUE id = rb_obj_id(object);
@@ -331,7 +325,6 @@ void fixup_varint_from_to(u8 *varint_start, u8 *varint_end, u32 number) {
     }
 }
 
-
 /*
  * Encodes object into Sereal
  */
@@ -440,8 +433,7 @@ method_sereal_encode(VALUE self, VALUE args) {
         s->size = compressed_len + s_header_len + compressed_len_varint + un_compressed_len_varint;
         s->pos = s->size;
     }
-
-    VALUE result = rb_str_new((char *) s->data,s->size);
+    VALUE ret = rb_str_new(s->data,s->size);
     s_destroy(s);
-    return result;
+    return ret;
 }

data/ext/sereal/proto.h

@@ -1,5 +1,6 @@
 #define SRL_MAGIC_STRING                "=srl"          /* Magic string for header. Every packet starts with this */
 #define SRL_MAGIC_STRING_UINT_LE     0x6c72733d      /* SRL_MAGIC_STRING as a little endian integer */
+#define SRL_MAGIC_STRING_UINT_LE_HB  0x6c72f33d      /* "=\xF3rl" */
 
 #define SRL_PROTOCOL_VERSION            ( 2 )           /* this is the first. for some reason we did not use 0 */
 #define SRL_PROTOCOL_VERSION_BITS       ( 4 )           /* how many bits we use for the version, the rest go to the encoding */

data/ext/sereal/sereal.h

@@ -13,6 +13,12 @@ typedef uint16_t u16;
 typedef uint8_t  u8;
 typedef struct _sereal          sereal_t;
 
+#ifndef __GNUC__
+#define __builtin_expect(a,b) a
+#endif
+#define likely(x)      __builtin_expect(!!(x), 1)
+#define unlikely(x)    __builtin_expect(!!(x), 0)
+#define SRL_MAX_VARINT_LENGTH 11
 #define TRUE 1
 #define FALSE 0
 #define MAX_RECURSION_DEPTH 100
@@ -46,11 +52,11 @@ typedef struct _sereal          sereal_t;
 #define SD(s,fmt,arg...)                                                \
     do {                                                                \
         if (s->flags & __DEBUG) {                                       \
-            int i;                                                      \
+            u32 i;                                                      \
             for (i = 0; i < s->level; i++) {                            \
                 printf(" ");                                            \
             }                                                           \
-            D(fmt " { p: %d, s: %d, l: %u, h: %u } ",##arg,s->pos,s->size,s->level,s->hdr_end); \
+            D(fmt " { p: %u, s: %u, l: %u, h: %u } ",##arg,s->pos,s->size,s->level,s->hdr_end); \
         }                                                               \
     } while(0);
 
@@ -88,6 +94,7 @@ extern ID TO_SRL;
 extern ID SEREAL;
 extern ID ID_CLASS;
 extern ID ID_VALUE;
+extern VALUE Sereal;
 extern VALUE SerealPerlObject;
 
 #define S_RECURSE_INC(s)                                            \

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sereal
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - Borislav Nikolov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-05 00:00:00.000000000 Z
+date: 2014-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler