inmemory_kv 0.1.1 → 0.1.2

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    MWU3YjA2NjJmYmQ0ZTg1NWE1NWE5MTBmMDg3YWEzNjUyOTI2ZTFiZQ==
-  data.tar.gz: !binary |-
-    Mjk4MWUzN2FhMmE1N2QyOGNjMWFmM2NmMWU1YjBhODcxNmRhNjM0Mw==
+SHA1:
+  metadata.gz: 4f83c12e65316b730f53c6d223859355b5fa8e00
+  data.tar.gz: 78c378060063ec7c7ce46721d775bfbdfcfcc741
 SHA512:
-  metadata.gz: !binary |-
-    N2M4MTRjZmEyZjY5OGYyNDg0YmMxNzAyOWJjMWQ3MDBlMzU1M2M2MzUzODkw
-    Njk2OTU4YWZkYmVkZmExNDYzOTJhZWE3YmRiNmQxZWUwYmE1ODIzYjMxOWFl
-    MWQ0ODI0YTk0YTQxY2RmNDEzYzFkOWIyYzk2YmEyNTI5ZThhYWM=
-  data.tar.gz: !binary |-
-    YjdlNDY4M2VjZGE2Njc5MzY2MmFmNjA3YThhYmM1YmRiOGI0NWM0MDgzMjU3
-    MDdhYjQzZTgwYTZhNjM0ZjY3NmU2ZTFkYTdkMTM5ZWZjZGU1Nzk1ZjU4ZTNi
-    MGUzYTY3ZGJiMTk2ZjAzMDVlNzE2MzZlZjE3M2QwZTJkM2YwZWI=
+  metadata.gz: a64d4273444283c58f16eb5cb17536073d708bf6e9e908f28647f74268d4e606d61244a4932c1066096637a9df5d272690cc67acec877dedb8156b58424a710c
+  data.tar.gz: 59f871c45e85e7fc198a4ebb8bd764f7676754bc9d384b1ca6ec9ed915976821d79e51f71bd6e476b9ea054ab15c5643e6f092a5fda5db76503f0b2fd125efda

data/ext/inmemory_kv.c

@@ -2,6 +2,7 @@
 #include <ruby/intern.h>
 #include <assert.h>
 #include <malloc.h>
+#include <stddef.h>
 
 #include <stdio.h>
 #ifdef HAV_STDLIB_H
@@ -10,19 +11,109 @@
 #include <string.h>
 
 typedef unsigned int u32;
+typedef unsigned char u8;
 
 typedef struct hash_item {
 	u32 pos;
-	u32 rc;
-	u32 key_size;
-	u32 val_size;
-	u32 val_size_max;
-	char key[0];
+	u32 rc : 31;
+	u32 big : 1;
+#ifndef HAVE_MALLOC_USABLE_SIZE
+	u32 item_size;
+#endif
+	union {
+		struct {
+			u8 key_size;
+			u8 val_size;
+			char key[0];
+		} small;
+		struct {
+			u32 key_size;
+			u32 val_size;
+			char key[0];
+		} big;
+	} kind;
 } hash_item;
 
+#ifdef HAVE_MALLOC_USABLE_SIZE
+static inline size_t
+item_size(hash_item* item) {
+	return malloc_usable_size(item);
+}
+#else
+static inline size_t
+item_size(hash_item* item) {
+	return item->item_size;
+}
+#endif
+
+static inline int
+item_need_big(u32 key_size, u32 val_size) {
+	return key_size > 255 || val_size > 255;
+}
+
+static inline u32
+item_key_size(hash_item* item) {
+	return item->big ? item->kind.big.key_size : item->kind.small.key_size;
+}
+
+static inline u32
+item_val_size(hash_item* item) {
+	return item->big ? item->kind.big.val_size : item->kind.small.val_size;
+}
+
+static inline void
+item_set_sizes(hash_item* item, u32 key_size, u32 val_size) {
+	if (item_need_big(key_size, val_size)) {
+		item->big = 1;
+		item->kind.big.key_size = key_size;
+		item->kind.big.val_size = val_size;
+	} else {
+		item->big = 0;
+		item->kind.small.key_size = key_size;
+		item->kind.small.val_size = val_size;
+	}
+}
+
+static inline void
+item_set_val_size(hash_item* item, u32 val_size) {
+	assert( (val_size > 255) == (item->big == 1));
+	if (item->big) {
+		item->kind.big.val_size = val_size;
+	} else {
+		item->kind.small.val_size = val_size;
+	}
+}
+
+static inline char*
+item_key(hash_item* item) {
+	return item->big ? item->kind.big.key : item->kind.small.key;
+}
+
 static inline char*
 item_val(hash_item* item) {
-	return item->key + item->key_size;
+	return item_key(item) + item_key_size(item);
+}
+
+static inline u32
+item_need_size(u32 key_size, u32 val_size) {
+	if (item_need_big(key_size, val_size)) {
+		return offsetof(hash_item, kind.big.key) + key_size + val_size;
+	} else {
+		return offsetof(hash_item, kind.small.key) + key_size + val_size;
+	}
+}
+
+static inline int
+item_compatible(hash_item* item, u32 val_size) {
+	u32 key_size, need_size, have_size;
+	key_size = item_key_size(item);
+	if (item->big != item_need_big(key_size, val_size))
+		return 0;
+	need_size = item_need_size(key_size, val_size);
+	have_size = item_size(item);
+	if (need_size > have_size || need_size < have_size/2)
+		return 0;
+	return 1;
 }
 
 typedef struct hash_entry {
@@ -152,7 +243,7 @@ hash_unchain(hash_table* tab, u32 pos) {
 
 static void
 hash_up(hash_table* tab, u32 pos) {
-	assert(tab->entries[pos].hash != 0);
+	assert(tab->entries[pos].item != NULL);
 	if (tab->last == pos+1) return;
 	hash_unchain(tab, pos);
 	hash_enchain(tab, pos);
@@ -160,7 +251,7 @@ hash_up(hash_table* tab, u32 pos) {
 
 static void
 hash_down(hash_table* tab, u32 pos) {
-	assert(tab->entries[pos].hash != 0);
+	assert(tab->entries[pos].item != NULL);
 	if (tab->first == pos+1) return;
 	hash_unchain(tab, pos);
 	hash_enchain_first(tab, pos);
@@ -187,7 +278,7 @@ hash_insert(hash_table* tab, u32 hash) {
 		free(tab->buckets);
 		tab->buckets = calloc(new_nbuckets, sizeof(u32));
 		for (i=0; i<tab->alloced; i++) {
-			if (tab->entries[i].hash == 0)
+			if (tab->entries[i].item == NULL)
 				continue;
 			buc = tab->entries[i].hash % new_nbuckets;
 			npos = tab->buckets[buc];
@@ -232,6 +323,7 @@ hash_delete(hash_table* tab, u32 pos) {
 	hash_unchain(tab, i);
 	tab->empty = i+1;
 	tab->entries[i].hash = 0;
+	tab->entries[i].item = NULL;
 	tab->size--;
 }
 
@@ -260,8 +352,7 @@ static void kv_copy_to(inmemory_kv *from, inmemory_kv *to);
 #ifdef HAV_RB_MEMHASH
 static inline u32
 kv_hash(const char* key, u32 key_size) {
-	u32 hash = rb_memhash(key, key_size);
-	return hash ? hash : ~(u32)0;
+	return rb_memhash(key, key_size);
 }
 #else
 static inline u32
@@ -274,8 +365,7 @@ kv_hash(const char* key, u32 key_size) {
 		a2 = (a2 ^ k) * 9;
 	}
 	a1 ^= key_size; a1 *= 5; a2 *= 9;
-	a1 ^= a2;
-	return a1 ? a1 : ~(u32)0;
+	return a1 ^ a2;
 }
 #endif
 
@@ -287,8 +377,8 @@ kv_insert(inmemory_kv *kv, const char* key, u32 key_size, const char* val, u32 v
 	pos = hash_hash_first(&kv->tab, hash);
 	while (pos != end) {
 		item = kv->tab.entries[pos].item;
-		if (item->key_size == key_size &&
-				memcmp(key, item->key, key_size) == 0) {
+		if (item_key_size(item) == key_size &&
+				memcmp(key, item_key(item), key_size) == 0) {
 			break;
 		}
 		pos = hash_hash_next(&kv->tab, hash, pos);
@@ -298,8 +388,8 @@ kv_insert(inmemory_kv *kv, const char* key, u32 key_size, const char* val, u32 v
 		item = NULL;
 	} else {
 		hash_up(&kv->tab, pos);
-		if (val_size > item->val_size_max || item->rc > 0) {
-			kv->total_size -= item->key_size + item->val_size_max + sizeof(*item);
+		if (!item_compatible(item, val_size) || item->rc > 0) {
+			kv->total_size -= item_size(item);
 			if (item->rc > 0)
 				item->rc--;
 			else
@@ -308,25 +398,25 @@ kv_insert(inmemory_kv *kv, const char* key, u32 key_size, const char* val, u32 v
 		}
 	}
 	if (item == NULL) {
+		u32 new_size = item_need_size(key_size, val_size);
 #ifdef HAVE_MALLOC_USABLE_SIZE
-		item = malloc(sizeof(*item) + key_size + val_size);
+		item = malloc(new_size);
 		assert(item);
+		new_size = malloc_usable_size(item);
 		item->rc = 0;
-		item->val_size_max = malloc_usable_size(item) - sizeof(*item) - key_size;
 #else
-		u32 val_size_max = sizeof(*item) + key_size + val_size;
-		val_size_max = (val_size_max + 15) & 15;
-		item = malloc(sizeof(*item) + key_size + val_size_max);
+		new_size = (new_size + 7) & 7;
+		item = malloc(new_size);
 		assert(item);
 		item->rc = 0;
-		item->val_size_max = val_size_max;
+		item->item_size = new_size;
 #endif
-		kv->total_size += key_size + item->val_size_max + sizeof(*item);
-		item->key_size = key_size;
+		kv->total_size += new_size;
+		item_set_sizes(item, key_size, val_size);
 		item->pos = pos;
-		memcpy(item->key, key, key_size);
+		memcpy(item_key(item), key, key_size);
 	}
-	item->val_size = val_size;
+	item_set_val_size(item, val_size);
 	memcpy(item_val(item), val, val_size);
 	kv->tab.entries[pos].item = item;
 	return item;
@@ -340,8 +430,8 @@ kv_fetch(inmemory_kv *kv, const char* key, u32 key_size) {
 	pos = hash_hash_first(&kv->tab, hash);
 	while (pos != end) {
 		item = kv->tab.entries[pos].item;
-		if (item->key_size == key_size &&
-				memcmp(key, item->key, key_size) == 0) {
+		if (item_key_size(item) == key_size &&
+				memcmp(key, item_key(item), key_size) == 0) {
 			break;
 		}
 		pos = hash_hash_next(&kv->tab, hash, pos);
@@ -362,7 +452,7 @@ kv_down(inmemory_kv *kv, hash_item* item) {
 static void
 kv_delete(inmemory_kv *kv, hash_item* item) {
 	hash_delete(&kv->tab, item->pos);
-	kv->total_size -= sizeof(*item) + item->key_size + item->val_size_max;
+	kv->total_size -= item_size(item);
 	if (item->rc > 0) {
 		item->rc--;
 	} else {
@@ -392,7 +482,7 @@ static void
 kv_destroy(inmemory_kv *kv) {
 	u32 i;
 	for (i=0; i<kv->tab.alloced; i++) {
-		if (kv->tab.entries[i].hash != 0) {
+		if (kv->tab.entries[i].item != NULL) {
 			hash_item* item = kv->tab.entries[i].item;
 			if (item->rc > 0) {
 				item->rc--;
@@ -417,7 +507,7 @@ kv_copy_to(inmemory_kv *from, inmemory_kv *to) {
 		memcpy(to->tab.buckets, from->tab.buckets,
 				sizeof(u32)*from->tab.nbuckets);
 		for (i=0; i<to->tab.alloced; i++) {
-			if (to->tab.entries[i].hash != 0) {
+			if (to->tab.entries[i].item != NULL) {
 				to->tab.entries[i].item->rc++;
 			}
 		}
@@ -455,6 +545,16 @@ rb_kv_alloc(VALUE klass) {
 	return TypedData_Wrap_Struct(klass, &InMemoryKV_data_type, kv);
 }
 
+static inline VALUE
+item_key_str(hash_item* item) {
+	return rb_str_new(item_key(item), item_key_size(item));
+}
+
+static inline VALUE
+item_val_str(hash_item* item) {
+	return rb_str_new(item_val(item), item_val_size(item));
+}
+
 static VALUE
 rb_kv_get(VALUE self, VALUE vkey) {
 	inmemory_kv* kv;
@@ -468,7 +568,7 @@ rb_kv_get(VALUE self, VALUE vkey) {
 	size = RSTRING_LEN(vkey);
 	item = kv_fetch(kv, key, size);
 	if (item == NULL) return Qnil;
-	return rb_str_new(item_val(item), item->val_size);
+	return item_val_str(item);
 }
 
 static VALUE
@@ -485,7 +585,7 @@ rb_kv_up(VALUE self, VALUE vkey) {
 	item = kv_fetch(kv, key, size);
 	if (item == NULL) return Qnil;
 	kv_up(kv, item);
-	return rb_str_new(item_val(item), item->val_size);
+	return item_val_str(item);
 }
 
 static VALUE
@@ -502,7 +602,7 @@ rb_kv_down(VALUE self, VALUE vkey) {
 	item = kv_fetch(kv, key, size);
 	if (item == NULL) return Qnil;
 	kv_down(kv, item);
-	return rb_str_new(item_val(item), item->val_size);
+	return item_val_str(item);
 }
 
 static VALUE
@@ -551,7 +651,7 @@ rb_kv_del(VALUE self, VALUE vkey) {
 	size = RSTRING_LEN(vkey);
 	item = kv_fetch(kv, key, size);
 	if (item == NULL) return Qnil;
-	res = rb_str_new(item_val(item), item->val_size);
+	res = item_val_str(item);
 	kv_delete(kv, item);
 	return res;
 }
@@ -565,8 +665,8 @@ rb_kv_first(VALUE self) {
 	GetKV(self, kv);
 	item = kv_first(kv);
 	if (item == NULL) return Qnil;
-	key = rb_str_new(item->key, item->key_size);
-	val = rb_str_new(item_val(item), item->val_size);
+	key = item_key_str(item);
+	val = item_val_str(item);
 	return rb_assoc_new(key, val);
 }
 
@@ -579,8 +679,8 @@ rb_kv_shift(VALUE self) {
 	GetKV(self, kv);
 	item = kv_first(kv);
 	if (item == NULL) return Qnil;
-	key = rb_str_new(item->key, item->key_size);
-	val = rb_str_new(item_val(item), item->val_size);
+	key = item_key_str(item);
+	val = item_val_str(item);
 	kv_delete(kv, item);
 	return rb_assoc_new(key, val);
 }
@@ -637,21 +737,21 @@ rb_kv_total_size(VALUE self) {
 static void
 keys_i(hash_item* item, void* arg) {
 	VALUE ary = (VALUE)arg;
-	rb_ary_push(ary, rb_str_new(item->key, item->key_size));
+	rb_ary_push(ary, item_key_str(item));
 }
 
 static void
 vals_i(hash_item* item, void* arg) {
 	VALUE ary = (VALUE)arg;
-	rb_ary_push(ary, rb_str_new(item_val(item), item->val_size));
+	rb_ary_push(ary, item_val_str(item));
 }
 
 static void
 pairs_i(hash_item* item, void* arg) {
 	VALUE ary = (VALUE)arg;
 	VALUE key, val;
-	key = rb_str_new(item->key, item->key_size);
-	val = rb_str_new(item_val(item), item->val_size);
+	key = item_key_str(item);
+	val = item_val_str(item);
 	rb_ary_push(ary, rb_assoc_new(key, val));
 }
 
@@ -687,19 +787,19 @@ rb_kv_entries(VALUE self) {
 
 static void
 key_i(hash_item* item, void* _ __attribute__((unused))) {
-	rb_yield(rb_str_new(item->key, item->key_size));
+	rb_yield(item_key_str(item));
 }
 
 static void
 val_i(hash_item* item, void* _ __attribute__((unused))) {
-	rb_yield(rb_str_new(item_val(item), item->val_size));
+	rb_yield(item_val_str(item));
 }
 
 static void
 pair_i(hash_item* item, void* _ __attribute__((unused))) {
 	VALUE key, val;
-	key = rb_str_new(item->key, item->key_size);
-	val = rb_str_new(item_val(item), item->val_size);
+	key = item_key_str(item);
+	val = item_val_str(item);
 	rb_yield(rb_assoc_new(key, val));
 }
 
@@ -737,14 +837,14 @@ static void
 inspect_i(hash_item* item, void* arg) {
 	struct inspect_arg* a = arg;
 	VALUE ins;
-	rb_str_cat(a->tmp, item->key, item->key_size);
+	rb_str_cat(a->tmp, item_key(item), item_key_size(item));
 	ins = rb_inspect(a->tmp);
 	rb_str_cat(a->str, " ", 1);
 	rb_str_cat(a->str, RSTRING_PTR(ins), RSTRING_LEN(ins));
 	rb_str_cat(a->str, "=>", 2);
 	rb_str_resize(ins, 0);
 	rb_str_resize(a->tmp, 0);
-	rb_str_buf_cat(a->tmp, item_val(item), item->val_size);
+	rb_str_buf_cat(a->tmp, item_val(item), item_val_size(item));
 	ins = rb_inspect(a->tmp);
 	rb_str_append(a->str, ins);
 	rb_str_resize(ins, 0);

data/lib/inmemory_kv/version.rb

@@ -1,3 +1,3 @@
 module InMemoryKV
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,55 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: inmemory_kv
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Sokolov Yura aka funny_falcon
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-30 00:00:00.000000000 Z
+date: 2015-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Simple in memory string/string hash
@@ -60,7 +60,7 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -82,19 +82,20 @@ require_paths:
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.4.4
 signing_key: 
 specification_version: 4
 summary: Simple in memory string/string hash
 test_files:
 - test/test_str2str.rb
+has_rdoc: