inmemory_kv 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YWFiZGI1MGRlM2I4MDg3NzFlZGEyYzBkMzAwOWU0MjFkNWY4ZGRiNQ==
+  data.tar.gz: !binary |-
+    ZjkxOTg3MTUzOWY0OTM1N2JhOGFiMmNkMDUzYjQ0ODQ3NDg3M2JhOQ==
+SHA512:
+  metadata.gz: !binary |-
+    YzFlNGQ3MmU1ODE1NDI4ZGEyOWU0MTYzYzdjYTlmMTgzMzRiMTM0ZjQ1YzUy
+    ZjI1MjM0YTBjNTUyMjEwODFhMzVjMmFmM2FlZTUwZmNhOWZkMjdiODUyYWY5
+    MjUxZDEzZGI4ZjAyNDAwZjI1MGIyNzM2MzVmMTcxOTU3MzI4ZDg=
+  data.tar.gz: !binary |-
+    MGVjZWZmMDM5YTQzYmVmMjEyNmU5YjVkYTAxNTExMjllMGJhM2VhNjczMDc0
+    OWIzYTczMGNmYTBlMzhlMzIwNTI2NDIxN2NmODNjNGJhZTdkZWYxYWY5MzVk
+    MTYwZjE4MGQ1N2Q2ZDYwYmE3MDI2NGYwNDI0YTZjZWFiZDY5MmI=

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in inmemory_kv.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Sokolov Yura aka funny_falcon
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# InMemoryKV
+
+This is simple off-gc in-memory hash table.
+
+Currently, `InMemoryKV::Str2Str` is a string to string hash table
+with LRU built in (a lot like builtin Hash).
+
+It doesn't participate in GC and not encounted in. It uses `malloc` for simplicity.
+
+If you do not clone and not mutate it in a fork, than it is as fork-frienly as your malloc is.
+
+It is not thread-safe, so protect it by you self. (builtin hash is also not thread-safe)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'inmemory_kv'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install inmemory_kv
+
+## Usage
+
+```ruby
+s2s = InMemoryKV::Str2Str.new
+s2s['asdf'] = 'qwer'
+s2s.keys
+s2s.values
+s2s.entries
+# attention: iteration is not as safe as iteration of builtin Hash.
+# Builtin Hash checks if you mutate hash during iteratation, this hash doesn't.
+s2s.each_key{|k| }
+s2s.each_value{|k| }
+s2s.each{|k,v| }
+
+s2s.up(k) # touch entry to be most recent in LRU order
+s2s.down(k) # touch entry to be first to expire
+s2s.first # first/oldest entry in LRU
+s2s.shift # shift oldest entry
+s2s.data_size # size of key+value entries
+s2s.total_size # size of key+value entries + internal structures
+
+# Str2Str is more memory efficient than storing string in a builtin hash
+# also it is a bit faster.
+# It tries to overwrite value inplace if it value's size not larger.
+def timeit; t=Time.now; r=yield; ensure puts "Lasts: #{Time.now - t}"; r; end
+
+timeit{ 1000000.times{|i| s2s[i.to_s] = "qwer#{i}"} }
+timeit{ 1000000.times{|i| s2s[i.to_s] = "qwer#{i}"} }
+hsh = {}
+timeit{ 1000000.times{|i| hsh[i.to_s] = "qwer#{i}"} }
+timeit{ 1000000.times{|i| hsh[i.to_s] = "qwer#{i}"} }
+
+# cloning is made to be very fast:
+# it does not copy key/value entries
+# only internal structures are alloced and copied with memcpy
+# key/value's reference count is incremented
+timeit{ sts.dup }
+timeit{ hsh.dup }
+# clone is copy on write
+cpy = sts.dup
+sts['2'] = '!'
+cpy['3'] = '!!'
+sts['2'] != cpy['2']
+sts['3'] != cpy['3']
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/funny-falcon/inmemory_kv/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do
+end
+

data/ext/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+have_func('malloc_usable_size')
+have_func('rb_memhash')
+create_makefile("inmemory_kv")

data/ext/inmemory_kv.c

@@ -0,0 +1,809 @@
+#include <ruby/ruby.h>
+#include <ruby/intern.h>
+#include <assert.h>
+#include <malloc.h>
+
+#include <stdio.h>
+#ifdef HAV_STDLIB_H
+#include <stdlib.h>
+#endif
+#include <string.h>
+
+typedef unsigned int u32;
+
+typedef struct hash_item {
+	u32 pos;
+	u32 rc;
+	u32 key_size;
+	u32 val_size;
+	u32 val_size_max;
+	char key[0];
+} hash_item;
+
+static inline char*
+item_val(hash_item* item) {
+	return item->key + item->key_size;
+}
+
+typedef struct hash_entry {
+	u32 hash;
+	u32 next;
+	u32 fwd;
+	u32 prev;
+	hash_item* item;
+} hash_entry;
+
+typedef struct hash_table {
+	hash_entry* entries;
+	u32* buckets;
+	u32  size;
+	u32  alloced;
+	u32  empty;
+	u32  first;
+	u32  last;
+	u32  nbuckets;
+} hash_table;
+
+static const u32 end = (u32)0 - 1;
+
+static u32 hash_first(hash_table* tab);
+static u32 hash_next(hash_table* tab, u32 pos);
+static u32 hash_hash_first(hash_table* tab, u32 hash);
+static u32 hash_hash_next(hash_table* tab, u32 hash, u32 pos);
+static u32 hash_insert(hash_table* tab, u32 hash);
+static void hash_up(hash_table* tab, u32 pos);
+static void hash_delete(hash_table* tab, u32 pos);
+static void hash_destroy(hash_table* tab);
+static size_t hash_memsize(const hash_table* tab) {
+	return tab->alloced * sizeof(hash_entry) +
+		tab->nbuckets * sizeof(u32);
+}
+
+static u32
+hash_first(hash_table* tab) {
+	return tab->first - 1;
+}
+
+static u32
+hash_next(hash_table* tab, u32 pos) {
+	if (pos == end || tab->alloced < pos) {
+		return end;
+	}
+	return tab->entries[pos].fwd - 1;
+}
+
+static u32
+hash_hash_first(hash_table* tab, u32 hash) {
+	u32 buc, pos;
+	if (tab->size == 0) return end;
+	buc = hash % tab->nbuckets;
+	pos = tab->buckets[buc] - 1;
+	while (pos != end && tab->entries[pos].hash != hash) {
+		pos = tab->entries[pos].next - 1;
+	}
+	return pos;
+}
+
+static u32
+hash_hash_next(hash_table* tab, u32 hash, u32 pos) {
+	if (pos == end || tab->size == 0) return end;
+	do {
+		pos = tab->entries[pos].next - 1;
+	} while (pos != end && tab->entries[pos].hash != hash);
+	return pos;
+}
+
+#if 0
+static void
+hash_print(hash_table* tab, const char* act, u32 pos) {
+	u32 i;
+	printf("%s %d size: %d first: %d last: %d\n", act, pos, tab->size, tab->first-1, tab->last-1);
+	i = tab->first;
+	while(i-1!=end) {
+		hash_entry* e = tab->entries + (i-1);
+		printf("\tpos: %d prev: %d fwd: %d\n", i-1, e->prev-1, e->fwd-1);
+		i = tab->entries[i-1].fwd;
+	}
+}
+#else
+#define hash_print(tab, act, pos)
+#endif
+
+static inline void
+hash_enchain(hash_table* tab, u32 pos) {
+	tab->entries[pos].prev = tab->last;
+	if (tab->first == 0) {
+		tab->first = pos+1;
+	} else {
+		tab->entries[tab->last-1].fwd = pos+1;
+	}
+	tab->last = pos+1;
+	hash_print(tab, "enchain", pos);
+}
+
+static inline void
+hash_enchain_first(hash_table* tab, u32 pos) {
+	tab->entries[pos].fwd = tab->first;
+	if (tab->last == 0) {
+		tab->last = pos+1;
+	} else {
+		tab->entries[tab->first-1].prev = pos+1;
+	}
+	tab->first = pos+1;
+	hash_print(tab, "enchain first", pos);
+}
+
+static inline void
+hash_unchain(hash_table* tab, u32 pos) {
+	if (tab->first == pos+1) {
+		tab->first = tab->entries[pos].fwd;
+	} else {
+		tab->entries[tab->entries[pos].prev-1].fwd = tab->entries[pos].fwd;
+	}
+	if (tab->last == pos+1) {
+		tab->last = tab->entries[pos].prev;
+	} else {
+		tab->entries[tab->entries[pos].fwd-1].prev = tab->entries[pos].prev;
+	}
+	tab->entries[pos].fwd = 0;
+	tab->entries[pos].prev = 0;
+	hash_print(tab, "unchain", pos);
+}
+
+static void
+hash_up(hash_table* tab, u32 pos) {
+	assert(tab->entries[pos].hash != 0);
+	if (tab->last == pos+1) return;
+	hash_unchain(tab, pos);
+	hash_enchain(tab, pos);
+}
+
+static void
+hash_down(hash_table* tab, u32 pos) {
+	assert(tab->entries[pos].hash != 0);
+	if (tab->first == pos+1) return;
+	hash_unchain(tab, pos);
+	hash_enchain_first(tab, pos);
+}
+
+static u32
+hash_insert(hash_table* tab, u32 hash) {
+	u32 i, pos, buc, npos;
+	if (tab->size == tab->alloced) {
+		u32 new_alloced = tab->alloced ? tab->alloced * 1.5 : 32;
+		tab->entries = realloc(tab->entries,
+				sizeof(hash_entry)*new_alloced);
+		assert(tab->entries);
+		memset(tab->entries + tab->alloced, 0,
+				sizeof(hash_entry)*(new_alloced - tab->alloced));
+		for (i=tab->alloced; i<new_alloced-1; i++) {
+			tab->entries[i].next = i+2;
+		}
+		tab->empty = tab->alloced+1;
+		tab->alloced = new_alloced;
+	}
+	if (tab->size >= tab->nbuckets * 2) {
+		u32 new_nbuckets = tab->nbuckets ? (tab->nbuckets+1)*2-1 : 15;
+		free(tab->buckets);
+		tab->buckets = calloc(new_nbuckets, sizeof(u32));
+		for (i=0; i<tab->alloced; i++) {
+			if (tab->entries[i].hash == 0)
+				continue;
+			buc = tab->entries[i].hash % new_nbuckets;
+			npos = tab->buckets[buc];
+			tab->entries[i].next = npos;
+			tab->buckets[buc] = i+1;
+		}
+		tab->nbuckets = new_nbuckets;
+	}
+	buc = hash % tab->nbuckets;
+	npos = tab->buckets[buc];
+	pos = tab->empty - 1;
+	assert(pos != end);
+	tab->buckets[buc] = pos + 1;
+	tab->empty = tab->entries[pos].next;
+	tab->entries[pos].hash = hash;
+	tab->entries[pos].item = NULL;
+	tab->entries[pos].next = npos;
+	tab->entries[pos].fwd = 0;
+	hash_enchain(tab, pos);
+	tab->size++;
+	return pos;
+}
+
+static void
+hash_delete(hash_table* tab, u32 pos) {
+	u32 hash, buc, i, j;
+	hash = tab->entries[pos].hash;
+	buc = hash % tab->nbuckets;
+	i = tab->buckets[buc] - 1;
+	j = end;
+	while (i != pos && i != end) {
+		j = i;
+		i = tab->entries[i].next - 1;
+	}
+	assert(i != end && i == pos);
+	if (j == end) {
+		tab->buckets[buc] = tab->entries[i].next;
+	} else {
+		tab->entries[j].next = tab->entries[i].next;
+	}
+	tab->entries[i].next = tab->empty;
+	hash_unchain(tab, i);
+	tab->empty = i+1;
+	tab->entries[i].hash = 0;
+	tab->size--;
+}
+
+static void
+hash_destroy(hash_table* tab) {
+	free(tab->entries);
+	free(tab->buckets);
+}
+
+typedef struct inmemory_kv {
+	hash_table tab;
+	size_t total_size;
+} inmemory_kv;
+
+static hash_item* kv_insert(inmemory_kv *kv, const char* key, u32 key_size, const char* val, u32 val_size);
+static hash_item* kv_fetch(inmemory_kv *kv, const char* key, u32 key_size);
+static void kv_up(inmemory_kv *kv, hash_item* item);
+static void kv_delete(inmemory_kv *kv, hash_item* item);
+static hash_item* kv_first(inmemory_kv *kv);
+
+typedef void (*kv_each_cb)(hash_item* item, void* arg);
+static void kv_each(inmemory_kv *kv, kv_each_cb cb, void* arg);
+
+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;
+}
+#else
+static inline u32
+kv_hash(const char* key, u32 key_size) {
+	u32 a1 = 0xdeadbeef, a2 = 0x71fefeed;
+	u32 i;
+	for (i = 0; i<key_size; i++) {
+		unsigned char k = key[i];
+		a1 = (a1 + k) * 5;
+		a2 = (a2 ^ k) * 9;
+	}
+	a1 ^= key_size; a1 *= 5; a2 *= 9;
+	a1 ^= a2;
+	return a1 ? a1 : ~(u32)0;
+}
+#endif
+
+static hash_item*
+kv_insert(inmemory_kv *kv, const char* key, u32 key_size, const char* val, u32 val_size) {
+	u32 hash = kv_hash(key, key_size);
+	u32 pos;
+	hash_item* item;
+	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) {
+			break;
+		}
+		pos = hash_hash_next(&kv->tab, hash, pos);
+	}
+	if (pos == end) {
+		pos = hash_insert(&kv->tab, hash);
+		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->rc > 0)
+				item->rc--;
+			else
+				free(item);
+			item = NULL;
+		}
+	}
+	if (item == NULL) {
+#ifdef HAVE_MALLOC_USABLE_SIZE
+		item = malloc(sizeof(*item) + key_size + val_size);
+		assert(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);
+		assert(item);
+		item->rc = 0;
+		item->val_size_max = val_size_max;
+#endif
+		kv->total_size += key_size + item->val_size_max + sizeof(*item);
+		item->key_size = key_size;
+		item->pos = pos;
+		memcpy(item->key, key, key_size);
+	}
+	item->val_size = val_size;
+	memcpy(item_val(item), val, val_size);
+	kv->tab.entries[pos].item = item;
+	return item;
+}
+
+static hash_item*
+kv_fetch(inmemory_kv *kv, const char* key, u32 key_size) {
+	u32 hash = kv_hash(key, key_size);
+	u32 pos;
+	hash_item* item;
+	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) {
+			break;
+		}
+		pos = hash_hash_next(&kv->tab, hash, pos);
+	}
+	return pos == end ? NULL : kv->tab.entries[pos].item;
+}
+
+static void
+kv_up(inmemory_kv *kv, hash_item* item) {
+	hash_up(&kv->tab, item->pos);
+}
+
+static void
+kv_down(inmemory_kv *kv, hash_item* item) {
+	hash_down(&kv->tab, item->pos);
+}
+
+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;
+	if (item->rc > 0) {
+		item->rc--;
+	} else {
+		free(item);
+	}
+}
+
+static hash_item*
+kv_first(inmemory_kv *kv) {
+	u32 pos = hash_first(&kv->tab);
+	if (pos != end) {
+		return kv->tab.entries[pos].item;
+	}
+	return NULL;
+}
+
+static void
+kv_each(inmemory_kv *kv, kv_each_cb cb, void* arg) {
+	u32 pos = hash_first(&kv->tab);
+	while (pos != end) {
+		cb(kv->tab.entries[pos].item, arg);
+		pos = hash_next(&kv->tab, pos);
+	}
+}
+
+static void
+kv_destroy(inmemory_kv *kv) {
+	u32 i;
+	for (i=0; i<kv->tab.alloced; i++) {
+		if (kv->tab.entries[i].hash != 0) {
+			hash_item* item = kv->tab.entries[i].item;
+			if (item->rc > 0) {
+				item->rc--;
+			} else {
+				free(item);
+			}
+		}
+	}
+	hash_destroy(&kv->tab);
+}
+
+static void
+kv_copy_to(inmemory_kv *from, inmemory_kv *to) {
+	kv_destroy(to);
+	*to = *from;
+	if (to->tab.alloced) {
+		u32 i;
+		to->tab.entries = malloc(to->tab.alloced*sizeof(hash_entry));
+		memcpy(to->tab.entries, from->tab.entries,
+				sizeof(hash_entry)*to->tab.alloced);
+		to->tab.buckets = malloc(to->tab.nbuckets*sizeof(u32));
+		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) {
+				to->tab.entries[i].item->rc++;
+			}
+		}
+	}
+}
+
+static size_t
+rb_kv_memsize(const void *p) {
+	if (p) {
+		const inmemory_kv* kv = p;
+		return sizeof(*kv) + kv->total_size + hash_memsize(&kv->tab);
+	}
+	return 0;
+}
+
+static void
+rb_kv_destroy(void *p) {
+	if (p) {
+		inmemory_kv *kv = p;
+		kv_destroy(kv);
+		free(kv);
+	}
+}
+
+static const rb_data_type_t InMemoryKV_data_type = {
+	"InMemoryKV_C",
+	{NULL, rb_kv_destroy, rb_kv_memsize}
+};
+#define GetKV(value, pointer) \
+	TypedData_Get_Struct((value), inmemory_kv, &InMemoryKV_data_type, (pointer))
+
+static VALUE
+rb_kv_alloc(VALUE klass) {
+	inmemory_kv* kv = calloc(1, sizeof(inmemory_kv));
+	return TypedData_Wrap_Struct(klass, &InMemoryKV_data_type, kv);
+}
+
+static VALUE
+rb_kv_get(VALUE self, VALUE vkey) {
+	inmemory_kv* kv;
+	const char *key;
+	size_t size;
+	hash_item* item;
+
+	GetKV(self, kv);
+	StringValue(vkey);
+	key = RSTRING_PTR(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);
+}
+
+static VALUE
+rb_kv_up(VALUE self, VALUE vkey) {
+	inmemory_kv* kv;
+	const char *key;
+	size_t size;
+	hash_item* item;
+
+	GetKV(self, kv);
+	StringValue(vkey);
+	key = RSTRING_PTR(vkey);
+	size = RSTRING_LEN(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);
+}
+
+static VALUE
+rb_kv_down(VALUE self, VALUE vkey) {
+	inmemory_kv* kv;
+	const char *key;
+	size_t size;
+	hash_item* item;
+
+	GetKV(self, kv);
+	StringValue(vkey);
+	key = RSTRING_PTR(vkey);
+	size = RSTRING_LEN(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);
+}
+
+static VALUE
+rb_kv_include(VALUE self, VALUE vkey) {
+	inmemory_kv* kv;
+	const char *key;
+	size_t size;
+
+	GetKV(self, kv);
+	StringValue(vkey);
+	key = RSTRING_PTR(vkey);
+	size = RSTRING_LEN(vkey);
+	return kv_fetch(kv, key, size) ? Qtrue : Qfalse;
+}
+
+static VALUE
+rb_kv_set(VALUE self, VALUE vkey, VALUE vval) {
+	inmemory_kv* kv;
+	const char *key, *val;
+	size_t ksize, vsize;
+
+	GetKV(self, kv);
+	StringValue(vkey);
+	StringValue(vval);
+	key = RSTRING_PTR(vkey);
+	ksize = RSTRING_LEN(vkey);
+	val = RSTRING_PTR(vval);
+	vsize = RSTRING_LEN(vval);
+
+	kv_insert(kv, key, ksize, val, vsize);
+
+	return vval;
+}
+
+static VALUE
+rb_kv_del(VALUE self, VALUE vkey) {
+	inmemory_kv* kv;
+	const char *key;
+	size_t size;
+	hash_item* item;
+	VALUE res;
+
+	GetKV(self, kv);
+	StringValue(vkey);
+	key = RSTRING_PTR(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);
+	kv_delete(kv, item);
+	return res;
+}
+
+static VALUE
+rb_kv_first(VALUE self) {
+	inmemory_kv* kv;
+	hash_item* item;
+	VALUE key, val;
+
+	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);
+	return rb_assoc_new(key, val);
+}
+
+static VALUE
+rb_kv_shift(VALUE self) {
+	inmemory_kv* kv;
+	hash_item* item;
+	VALUE key, val;
+
+	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);
+	kv_delete(kv, item);
+	return rb_assoc_new(key, val);
+}
+
+static VALUE
+rb_kv_unshift(VALUE self, VALUE vkey, VALUE vval) {
+	inmemory_kv* kv;
+	const char *key, *val;
+	size_t ksize, vsize;
+	hash_item* item;
+
+	GetKV(self, kv);
+	StringValue(vkey);
+	StringValue(vval);
+	key = RSTRING_PTR(vkey);
+	ksize = RSTRING_LEN(vkey);
+	val = RSTRING_PTR(vval);
+	vsize = RSTRING_LEN(vval);
+
+	item = kv_insert(kv, key, ksize, val, vsize);
+	kv_down(kv, item);
+
+	return vval;
+}
+
+static VALUE
+rb_kv_size(VALUE self) {
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	return UINT2NUM(kv->tab.size);
+}
+
+static VALUE
+rb_kv_empty_p(VALUE self) {
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	return kv->tab.size ? Qfalse : Qtrue;
+}
+
+static VALUE
+rb_kv_data_size(VALUE self) {
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	return SIZET2NUM(kv->total_size);
+}
+
+static VALUE
+rb_kv_total_size(VALUE self) {
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	return SIZET2NUM(rb_kv_memsize(kv));
+}
+
+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));
+}
+
+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));
+}
+
+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);
+	rb_ary_push(ary, rb_assoc_new(key, val));
+}
+
+static VALUE
+rb_kv_keys(VALUE self) {
+	inmemory_kv* kv;
+	VALUE res;
+	GetKV(self, kv);
+	res = rb_ary_new2(kv->tab.size);
+	kv_each(kv, keys_i, (void*)res);
+	return res;
+}
+
+static VALUE
+rb_kv_vals(VALUE self) {
+	inmemory_kv* kv;
+	VALUE res;
+	GetKV(self, kv);
+	res = rb_ary_new2(kv->tab.size);
+	kv_each(kv, vals_i, (void*)res);
+	return res;
+}
+
+static VALUE
+rb_kv_entries(VALUE self) {
+	inmemory_kv* kv;
+	VALUE res;
+	GetKV(self, kv);
+	res = rb_ary_new2(kv->tab.size);
+	kv_each(kv, pairs_i, (void*)res);
+	return res;
+}
+
+static void
+key_i(hash_item* item, void* _ __attribute__((unused))) {
+	rb_yield(rb_str_new(item->key, item->key_size));
+}
+
+static void
+val_i(hash_item* item, void* _ __attribute__((unused))) {
+	rb_yield(rb_str_new(item_val(item), item->val_size));
+}
+
+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);
+	rb_yield(rb_assoc_new(key, val));
+}
+
+static VALUE
+rb_kv_each_key(VALUE self) {
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	RETURN_ENUMERATOR(self, 0, 0);
+	kv_each(kv, key_i, NULL);
+	return self;
+}
+
+static VALUE
+rb_kv_each_val(VALUE self) {
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	RETURN_ENUMERATOR(self, 0, 0);
+	kv_each(kv, val_i, NULL);
+	return self;
+}
+
+static VALUE
+rb_kv_each(VALUE self) {
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	RETURN_ENUMERATOR(self, 0, 0);
+	kv_each(kv, pair_i, NULL);
+	return self;
+}
+
+struct inspect_arg {
+	VALUE str, tmp;
+};
+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);
+	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);
+	ins = rb_inspect(a->tmp);
+	rb_str_append(a->str, ins);
+	rb_str_resize(ins, 0);
+	rb_str_resize(a->tmp, 0);
+}
+
+static VALUE
+rb_kv_inspect(VALUE self) {
+	struct inspect_arg ins;
+	inmemory_kv* kv;
+	GetKV(self, kv);
+	ins.str = rb_str_buf_new2("<");
+	rb_str_append(ins.str, rb_class_name(CLASS_OF(self)));
+	if (kv->tab.size != 0) {
+		ins.tmp = rb_str_buf_new(0);
+		kv_each(kv, inspect_i, &ins);
+	}
+	rb_str_buf_cat2(ins.str, ">");
+	return ins.str;
+}
+
+static VALUE
+rb_kv_init_copy(VALUE self, VALUE orig) {
+	inmemory_kv *origin, *new;
+	GetKV(self, new);
+	GetKV(orig, origin);
+	kv_copy_to(origin, new);
+	return self;
+}
+
+void
+Init_inmemory_kv() {
+	VALUE mod_inmemory_kv, cls_str2str;
+	mod_inmemory_kv = rb_define_module("InMemoryKV");
+	cls_str2str = rb_define_class_under(mod_inmemory_kv, "Str2Str", rb_cObject);
+	rb_define_alloc_func(cls_str2str, rb_kv_alloc);
+	rb_define_method(cls_str2str, "[]", rb_kv_get, 1);
+	rb_define_method(cls_str2str, "up", rb_kv_up, 1);
+	rb_define_method(cls_str2str, "down", rb_kv_down, 1);
+	rb_define_method(cls_str2str, "[]=", rb_kv_set, 2);
+	rb_define_method(cls_str2str, "unshift", rb_kv_unshift, 2);
+	rb_define_method(cls_str2str, "delete", rb_kv_del, 1);
+	rb_define_method(cls_str2str, "empty?", rb_kv_empty_p, 0);
+	rb_define_method(cls_str2str, "size", rb_kv_size, 0);
+	rb_define_method(cls_str2str, "count", rb_kv_size, 0);
+	rb_define_method(cls_str2str, "data_size", rb_kv_data_size, 0);
+	rb_define_method(cls_str2str, "total_size", rb_kv_total_size, 0);
+	rb_define_method(cls_str2str, "include?", rb_kv_include, 1);
+	rb_define_method(cls_str2str, "has_key?", rb_kv_include, 1);
+	rb_define_method(cls_str2str, "first", rb_kv_first, 0);
+	rb_define_method(cls_str2str, "shift", rb_kv_shift, 0);
+	rb_define_method(cls_str2str, "keys", rb_kv_keys, 0);
+	rb_define_method(cls_str2str, "values", rb_kv_vals, 0);
+	rb_define_method(cls_str2str, "entries", rb_kv_entries, 0);
+	rb_define_method(cls_str2str, "each_key", rb_kv_each_key, 0);
+	rb_define_method(cls_str2str, "each_value", rb_kv_each_val, 0);
+	rb_define_method(cls_str2str, "each_pair", rb_kv_each, 0);
+	rb_define_method(cls_str2str, "each", rb_kv_each, 0);
+	rb_define_method(cls_str2str, "inspect", rb_kv_inspect, 0);
+	rb_define_method(cls_str2str, "initialize_copy", rb_kv_init_copy, 1);
+	rb_include_module(cls_str2str, rb_mEnumerable);
+}

data/inmemory_kv.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'inmemory_kv/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "inmemory_kv"
+  spec.version       = InMemoryKV::VERSION
+  spec.authors       = ["Sokolov Yura aka funny_falcon"]
+  spec.email         = ["funny.falcon@gmail.com"]
+  spec.summary       = %q{Simple in memory string/string hash}
+  spec.description   = %q{Simple in memory string/string hash}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.extensions    = ["ext/extconf.rb"]
+  spec.require_paths = ["lib", "ext"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/lib/inmemory_kv.rb

@@ -0,0 +1,6 @@
+require "inmemory_kv.so"
+require "inmemory_kv/version"
+
+module InMemoryKV
+  # Your code goes here...
+end

data/lib/inmemory_kv/version.rb

@@ -0,0 +1,3 @@
+module InMemoryKV
+  VERSION = "0.1.0"
+end

data/test/test_str2str.rb

@@ -0,0 +1,198 @@
+require 'inmemory_kv'
+require 'minitest/spec'
+require 'minitest/autorun'
+
+describe InMemoryKV::Str2Str do
+  let(:s2s) { InMemoryKV::Str2Str.new }
+  it "should be setable" do
+    s2s['asdf'] = 'qwer'
+  end
+  it "should be fetchable" do
+    s2s['asdf'].must_be_nil
+  end
+  it "should be inspected" do
+    s2s.inspect.must_equal '<InMemoryKV::Str2Str>'
+  end
+  it "is empty" do
+    s2s.must_be_empty
+  end
+  it "has zero size" do
+    s2s.size.must_equal 0
+  end
+  it "has zero data_size" do
+    s2s.data_size.must_equal 0
+  end
+  it "should have nil first" do
+    s2s.first.must_be_nil
+  end
+  it "should have no keys nor values nor entries" do
+    s2s.keys.must_be_empty
+    s2s.values.must_be_empty
+    s2s.entries.must_be_empty
+  end
+  it "should not iterate" do
+    s2s.each_key{ raise }
+    s2s.each_value{ raise }
+    s2s.each{ raise }
+  end
+
+  describe "filled with one item" do
+    before do
+      s2s['asdf'] = 'qwer'
+    end
+    it "should be inspectable" do
+      s2s.inspect.must_equal '<InMemoryKV::Str2Str "asdf"=>"qwer">'
+    end
+    it "should be fetchable" do
+      s2s['asdf'].must_equal 'qwer'
+    end
+    it "should has size == 1" do
+      s2s.size.must_equal 1
+    end
+    it "should has nonzero data_size" do
+      s2s.data_size.wont_equal 0
+    end
+    it "first should not be nil" do
+      s2s.first.must_equal ["asdf", "qwer"]
+    end
+    it "should react on delete" do
+      s2s.delete("asdf").must_equal('qwer')
+      s2s.size.must_equal 0
+      s2s.data_size.must_equal 0
+      s2s.first.must_be_nil
+      s2s.each{ raise }
+    end
+    it "should react on shift" do
+      s2s.shift.must_equal(['asdf','qwer'])
+      s2s.size.must_equal 0
+      s2s.data_size.must_equal 0
+      s2s.first.must_be_nil
+      s2s.each{ raise }
+    end
+    it "should allow rewrite value" do
+      s2s['asdf'] = 'zxcv'
+      s2s['asdf'].must_equal 'zxcv'
+    end
+    it "should allow dup, and perform copy on write" do
+      copy = s2s.dup
+      copy['asdf'].must_equal 'qwer'
+      s2s['asdf'] = 'zxcv'
+      s2s['asdf'].must_equal 'zxcv'
+      copy['asdf'].must_equal 'qwer'
+    end
+  end
+
+  describe "filled with two items" do
+    before do
+      s2s['asdf'] = 'qwer'
+      s2s['qwer'] = 'zxcv'
+    end
+    it "should be inspectable" do
+      s2s.inspect.must_equal '<InMemoryKV::Str2Str "asdf"=>"qwer" "qwer"=>"zxcv">'
+    end
+    it "should be fetchable" do
+      s2s['asdf'].must_equal 'qwer'
+      s2s['qwer'].must_equal 'zxcv'
+    end
+    it "should has size == 2" do
+      s2s.size.must_equal 2
+    end
+    it "first should not be nil" do
+      s2s.first.must_equal ["asdf", "qwer"]
+    end
+    it "should react on delete" do
+      s2s.delete("asdf").must_equal('qwer')
+      s2s.size.must_equal 1
+      s2s.first.must_equal ['qwer', 'zxcv']
+      s2s.delete("qwer").must_equal('zxcv')
+      s2s.data_size.must_equal 0
+      s2s.each{ raise }
+    end
+    it "should react on shift" do
+      s2s.shift.must_equal(['asdf','qwer'])
+      s2s.size.must_equal 1
+      s2s.shift.must_equal ['qwer', 'zxcv']
+      s2s.size.must_equal 0
+      s2s.data_size.must_equal 0
+      s2s.first.must_be_nil
+      s2s.each{ raise }
+    end
+    it "should reorder on set" do
+      s2s['asdf'] = 'yuio'
+      s2s.first.must_equal ['qwer', 'zxcv']
+      s2s.entries.must_equal [
+        ['qwer', 'zxcv'],
+        ['asdf', 'yuio']
+      ]
+    end
+    it "should allow explicit reorder" do
+      s2s.up 'asdf'
+      s2s.entries.must_equal [
+        ['qwer', 'zxcv'],
+        ['asdf', 'qwer']
+      ]
+      s2s.down 'asdf'
+      s2s.entries.must_equal [
+        ['asdf', 'qwer'],
+        ['qwer', 'zxcv']
+      ]
+    end
+    it "should allow dup, and perform copy on write" do
+      copy = s2s.dup
+      copy['asdf'].must_equal 'qwer'
+      s2s['asdf'] = 'zxcv'
+      s2s['asdf'].must_equal 'zxcv'
+      copy['asdf'].must_equal 'qwer'
+
+      s2s['qwer'].must_equal 'zxcv'
+      copy['qwer'].must_equal 'zxcv'
+    end
+  end
+
+  describe "huge filled" do
+    let(:num) { 1000 }
+    before do
+      num.times do |i|
+        s2s[i.to_s] = "q#{i}"
+      end
+    end
+    let(:hsh) do
+      h = {}
+      num.times do |i|
+        h[i.to_s] = "q#{i}"
+      end
+      h
+    end
+    it "should store all values" do
+      num.times do |i|
+        s2s[i.to_s].must_equal "q#{i}"
+      end
+    end
+    it "should report entries" do
+      s2s.entries.must_equal hsh.entries
+    end
+    it "should delete entries" do
+      2.step(num, 2) do |i|
+        s2s.delete(i.to_s).must_equal hsh.delete(i.to_s)
+      end
+      1.step(num, 2) do |i|
+        s2s[i.to_s].must_equal hsh[i.to_s]
+      end
+      s2s.size.must_equal hsh.size
+      s2s.entries.must_equal hsh.entries
+    end
+    it "should reorder on set" do
+      s2s.first.must_equal ['0', 'q0']
+      s2s['0'] = 'ya'
+      s2s.first.must_equal ['1', 'q1']
+      s2s.entries.last.must_equal ['0', 'ya']
+    end
+    it "should allow explicit reorder" do
+      s2s.up '235'
+      s2s.entries.last.must_equal ['235', 'q235']
+      s2s.down '235'
+      s2s.first.must_equal ['235', 'q235']
+      s2s.entries.last.wont_equal ['235', 'q235']
+    end
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: inmemory_kv
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Sokolov Yura aka funny_falcon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-30 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
+email:
+- funny.falcon@gmail.com
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/extconf.rb
+- ext/inmemory_kv.c
+- inmemory_kv.gemspec
+- lib/inmemory_kv.rb
+- lib/inmemory_kv/version.rb
+- test/test_str2str.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- 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
+signing_key: 
+specification_version: 4
+summary: Simple in memory string/string hash
+test_files:
+- test/test_str2str.rb