localmemcache 0.0.1

data/src/lmc_valloc.c

@@ -0,0 +1,324 @@
+/*
+ * Copyright (c) 2009, Sven C. Koehler
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+
+#include "lmc_valloc.h"
+
+#include "lmc_lock.h"
+
+typedef struct {
+  size_t next;
+  size_t size;
+} mem_chunk_descriptor_t;
+
+mem_chunk_descriptor_t *md_first_free(void *base) {
+  mem_descriptor_t *md = base;
+  return md->first_free == 0 ? 0 : base + md->first_free;
+}
+
+void lmc_dump_chunk(void *base, mem_chunk_descriptor_t* c) {
+  size_t va_c = (void *)c - base;
+  printf("chunk %zd:\n"
+      "  start: %zd\n"
+      "  end  : %zd\n"
+      "  size : %zd\n"
+      "  next : %zd\n"
+      "  ------------------------\n"
+      , va_c, va_c, va_c + c->size, c->size, c->next);
+}
+
+void lmc_dump_chunk_brief(char *who, void *base, mem_chunk_descriptor_t* c) {
+  if (!c) { return; }
+  size_t va_c = (void *)c - base;
+  printf("[%s] chunk %zd:\n", who, va_c);
+}
+
+
+void lmc_dump(void *base) {
+  mem_chunk_descriptor_t* c = md_first_free(base);
+  size_t free = 0;
+  long chunks = 0;
+  while (c) { 
+    lmc_dump_chunk(base, c);
+    free += c->size; 
+    chunks++; 
+    if (c->next == 0) { c = 0; } else { c = base + c->next;  }
+  }
+}
+
+int is_va_valid(void *base, size_t va) {
+  mem_descriptor_t *md = base;
+  mem_chunk_descriptor_t* c = base + va;
+  return !(((void *)c < base ) || (base + md->total_size + sizeof(mem_descriptor_t)) < (void *)c);
+}
+
+mem_status_t lmc_status(void *base, char *where) {
+  mem_descriptor_t *md = base;
+  mem_chunk_descriptor_t* c = md_first_free(base);
+  mem_status_t ms;
+  size_t free = 0;
+  size_t largest_chunk = 0;
+  long chunks = 0;
+  ms.total_mem = md->total_size;
+  while (c) { 
+    if (!is_va_valid(base, (void *)c - base)) {
+      printf("[%s] invalid pointer detected: %ld...\n", where, (void *)c - base);
+      lmc_dump(base);
+      abort();
+    }
+    free += c->size; 
+    if (c->size > largest_chunk) { largest_chunk = c->size; }
+    chunks++; 
+    if (c->next == 0) { c = 0; } else { c = base + c->next;  }
+  }
+  ms.total_free_mem = free;
+  ms.free_mem = free > 0 ? free - sizeof(size_t)  : 0;
+  ms.largest_chunk = largest_chunk;
+  ms.free_chunks = chunks;
+  return ms;
+}
+
+void lmc_show_status(void *base) {
+  mem_status_t ms = lmc_status(base, "lmc_ss");
+  printf("total: %zu\n", ms.total_mem);
+  printf("chunks: %zu, free: %zu\n", ms.free_chunks, ms.free_mem);
+}
+
+int is_lmc_already_initialized(void *base) {
+  mem_descriptor_t *md = base;
+  if (md->magic == 0xF00D) {
+#ifdef LMC_DEBUG_ALLOC
+    printf("memory already initialized, skipping...\n");
+#endif
+    return 1;
+  }
+  return 0;
+}
+
+void lmc_init_memory(void *ptr, size_t size) {
+  mem_descriptor_t *md = ptr;
+  size_t s = size - sizeof(mem_descriptor_t);
+  // size: enough space for mem_descriptor_t + mem_chunk_descriptor_t
+  md->first_free = sizeof(mem_descriptor_t);
+  md->magic = 0xF00D;
+  md->locked = 0;
+  md->total_size = s;
+  mem_chunk_descriptor_t *c = ptr + sizeof(mem_descriptor_t);
+  c->next = 0;
+  c->size = s;
+}
+
+size_t lmc_max(size_t a, size_t b) { 
+  return a > b ? a : b;
+}
+
+size_t __s(char *where, mem_status_t ms, size_t mem_before, size_t expected_diff) {
+  size_t free = ms.total_free_mem;
+  printf("(%s) ", where);
+  if (mem_before) { printf("[%ld:%zd] ", free - mem_before, expected_diff); }
+  printf("mem_free: %zu, chunks: %zu\n", free, ms.free_chunks);
+  if (expected_diff && expected_diff != free - mem_before) {
+    printf("expected_diff (%zu) != diff (%ld)\n", expected_diff, 
+        free - mem_before);
+    abort();
+  }
+  return free;
+}
+
+size_t lmc_valloc(void *base, size_t size) {
+  mem_descriptor_t *md = base;
+  // MOD by power of 2
+  size_t s = lmc_max(size + sizeof(size_t), 
+      sizeof(mem_chunk_descriptor_t) + sizeof(size_t));
+  // larger than available space?
+  mem_chunk_descriptor_t *c = md_first_free(base);
+  mem_chunk_descriptor_t *p = NULL;
+  if (size == 0) { return 0; }
+  while (c && c->size <s ) { 
+    p = c;
+    if (c->next == 0) {
+      c = 0;
+      break;
+    }
+    c = base + c->next; 
+  }
+  if (!c) {
+    //fprintf(stderr, "lmc_valloc: Failed to allocate %d bytes!\n", size);
+    return 0;
+  }
+  size_t r = 0;
+  if (c->size - s < sizeof(mem_chunk_descriptor_t)) { s = c->size; }
+  // -----------------           -------------------
+  // | chunk         |   wanted: |                 |
+  // -----------------           -------------------
+  if (c->size == s) {
+    if (p) { p->next = c->next; }
+    else {md->first_free = c->next; }
+    r = (size_t)((void*)c - (void*)base);
+  } else {
+  // -----------------           -------------------
+  // | chunk         |   wanted: |                 |
+  // |               |           -------------------
+  // -----------------           
+    c->size -= s;
+    r = (size_t)((void*)c - base) + c->size;
+  }
+  *(size_t *)(r + base) = s;
+  return r + sizeof(size_t);
+}
+
+// compact_chunks, 
+void lmc_check_coalesce(void *base, size_t va_chunk) {
+  mem_descriptor_t *md = base;
+  mem_chunk_descriptor_t *chunk = base + va_chunk;
+  size_t c_size = chunk->size;
+  size_t va_chunk_p = 0;
+  size_t va_c_free_chunk = 0;
+  mem_chunk_descriptor_t* c_free_chunk = base + va_c_free_chunk;
+  size_t va_previous = 0;
+  size_t merge1_chunk = 0;
+  int merge1 = 0;
+  while (c_free_chunk) {
+    va_c_free_chunk = (void *)c_free_chunk - base;
+    if (va_c_free_chunk != va_chunk) { 
+      if (c_free_chunk->next == va_chunk) { va_chunk_p = va_c_free_chunk; }
+      else if (!merge1) {
+        // ---------------------- 
+        // | a_free_chunk        |
+        // ----------------------   <---- if (...)  
+        // | chunk               |
+        // ----------------------
+        if (va_c_free_chunk + c_free_chunk->size == va_chunk) { 
+          merge1 = 1;
+          merge1_chunk = va_c_free_chunk;
+        } else 
+        // ---------------------- 
+        // | chunk               |
+        // ----------------------   <---- if (...) 
+        // | a_free_chunk        |
+        // ----------------------
+        if (va_chunk + c_size == va_c_free_chunk) { 
+          chunk->size += c_free_chunk->size;
+          if (chunk->next == va_c_free_chunk) { va_previous = va_chunk; }
+          mem_chunk_descriptor_t *p = va_previous ? base + va_previous : 0;
+          if (p) { p->next = c_free_chunk->next; }
+          break;
+        }
+      }
+      va_previous = va_c_free_chunk;
+    }
+    va_c_free_chunk = c_free_chunk->next;
+    if (va_c_free_chunk == 0) { c_free_chunk = NULL; }
+    else { c_free_chunk = base + va_c_free_chunk; }
+  }
+  // ---------------------- 
+  // | a_free_chunk        |
+  // ----------------------   <---- if (...)  
+  // | chunk               |
+  // ----------------------
+  if (merge1) {
+    mem_chunk_descriptor_t *cd = base + merge1_chunk;
+    mem_chunk_descriptor_t *p = va_chunk_p ? base + va_chunk_p : 0;
+    mem_chunk_descriptor_t *vacd = va_chunk? base + va_chunk : 0;
+    if (p) { p->next = vacd->next; }
+    if (md->first_free == va_chunk) { md->first_free = chunk->next; }
+    cd->size += c_size;
+  }
+}
+
+
+void lmc_free(void *base, size_t chunk) {
+#ifdef LMC_DEBUG_ALLOC
+  size_t mb = __s("free1", lmc_status(base, "lmc_free1"), 0, 0);
+#endif
+  if (chunk == 0) { return; }
+  mem_descriptor_t *md = base;
+  size_t va_used_chunk = chunk - sizeof(size_t);
+  void *used_chunk_p = base + va_used_chunk;
+  mem_chunk_descriptor_t *mcd_used_chunk = used_chunk_p;
+  size_t uc_size = *(size_t *)used_chunk_p;
+  size_t va_c_free_chunk = 0;
+  mem_chunk_descriptor_t* c_free_chunk = base + va_c_free_chunk;
+  size_t va_previous = 0;
+  size_t va_c_free_end = 0;
+  if (!(chunk >= sizeof(mem_descriptor_t) + sizeof(size_t)) ||
+      !is_va_valid(base, chunk)) {
+    printf("lmc_free: Invalid pointer: %zd\n", chunk);
+    return;
+  }
+#ifdef LMC_DEBUG_ALLOC
+  if (uc_size == 0) {
+    printf("SIZE is 0!\n");
+    lmc_dump(base);
+    abort();
+  }
+  memset(base + chunk, 0xF9, uc_size - sizeof(size_t));
+#endif
+  int freed = 0;
+  while (c_free_chunk) {
+    va_c_free_chunk = (void *)c_free_chunk - base;
+    va_c_free_end = va_c_free_chunk + c_free_chunk->size;
+    // ---------------------- 
+    // | c_free_chunk        |
+    // ----------------------   <---- if (...)  
+    // | used_chunk          |
+    // ----------------------
+    if (va_c_free_end == va_used_chunk) { 
+      freed = 1;
+      c_free_chunk->size += uc_size;
+      lmc_check_coalesce(base, va_c_free_chunk);
+      break;
+    } else 
+    // ---------------------- 
+    // | used_chunk          |
+    // ----------------------   <---- if (...) 
+    // | c_free_chunk        |
+    // ----------------------
+    if (va_used_chunk + uc_size == va_c_free_chunk) { 
+      freed = 1;
+      mem_chunk_descriptor_t *p = base + va_previous;
+      mcd_used_chunk->next = c_free_chunk->next;
+      mcd_used_chunk->size = uc_size + c_free_chunk->size;
+      p->next = va_used_chunk;
+      lmc_check_coalesce(base, va_used_chunk);
+      break;
+    }
+    if (va_used_chunk >= va_c_free_chunk && va_used_chunk <= va_c_free_end) {
+      fprintf(stderr, "Was pointer already freed?\n");
+      return;
+    }
+    va_previous = va_c_free_chunk;
+    va_c_free_chunk = c_free_chunk->next;
+    if (va_c_free_chunk == 0) { c_free_chunk = NULL; }
+    else { c_free_chunk = base + va_c_free_chunk; }
+  }
+  // ---------------------- 
+  // | otherwise allocated |
+  // ---------------------- 
+  // | used_chunk          |
+  // ----------------------   
+  // | otherwise allocated |
+  // ----------------------
+  if (!freed) {
+    mcd_used_chunk->next = md->first_free;
+    mcd_used_chunk->size = uc_size;
+    md->first_free = va_used_chunk;
+  }
+#ifdef LMC_DEBUG_ALLOC
+  __s("free2", lmc_status(base, "lmc_free2"), mb, uc_size);
+#endif
+}
+
+void lmc_realloc(void *base, size_t chunk) {
+  // check if enough reserved space, true: resize; otherwise: alloc new and 
+  // then free
+}

data/src/lmc_valloc.h

@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2009, Sven C. Koehler
+ */
+
+#ifndef _LMC_VALLOC_H_INCLUDED_
+#define _LMC_VALLOC_H_INCLUDED_
+#undef LMC_DEBUG_ALLOC
+typedef struct {
+  size_t free_chunks;
+  size_t total_mem;
+  size_t total_free_mem;
+  size_t free_mem;
+  size_t largest_chunk;
+} mem_status_t;
+
+typedef struct {
+  size_t first_free;
+  size_t dummy2;
+  size_t total_size;
+  size_t magic;
+  size_t va_hash;
+  int locked;
+} mem_descriptor_t;
+
+
+size_t lmc_valloc(void *base, size_t size);
+void lmc_free(void *base, size_t chunk);
+mem_status_t lmc_status(void *base, char *where);
+int is_lmc_already_initialized(void *base);
+void lmc_init_memory(void *ptr, size_t size);
+#endif

data/src/localmemcache.c

@@ -0,0 +1,130 @@
+#include "localmemcache.h"
+#include <stdio.h>
+#include <string.h>
+#include "lmc_valloc.h"
+#include "lmc_shm.h"
+
+int lmc_set_lock_flag(void *base, lmc_error_t *e) {
+  mem_descriptor_t *md = base;
+  if (md->locked != 0) {
+    strncpy(e->error_str, "Failed to lock shared memory region--"
+        "may be corrupt.", 1023); 
+    return 0;
+  } else {
+    md->locked = 1;
+  }
+  return 1;
+}
+
+int lmc_release_lock_flag(void *base, lmc_error_t *e) {
+  mem_descriptor_t *md = base;
+  if (md->locked != 1) {
+    strncpy(e->error_str, "Shared memory region appears to be unlocked already"
+        "--may be corrupt.", 1023); 
+    return 0;
+  } else {
+    md->locked = 0;
+  }
+  return 1;
+}
+
+int local_memcache_clear_namespace(const char *namespace, int repair, 
+    lmc_error_t *e) {
+  lmc_clean_namespace(namespace, e);
+  if (repair) { 
+    lmc_lock_t *l = lmc_lock_init(namespace, 1, e);
+    lmc_lock_repair(l);
+    free(l);
+  }
+  return 1;
+}
+
+local_memcache_t *local_memcache_create(const char *namespace, size_t size,
+    lmc_error_t* e) {
+  local_memcache_t *lmc = calloc(1, sizeof(local_memcache_t));
+  if (!lmc || (lmc->namespace = strdup(namespace)) == NULL) return NULL;
+  lmc->size = size;
+  if ((lmc->lock = lmc_lock_init(lmc->namespace, 1, e)) == NULL) goto failed;
+  if (!lmc_is_lock_working(lmc->lock, e)) {
+    strncpy(e->error_str, "Failed to lock shared memory!", 1023); 
+    goto failed;
+  }
+  {
+    if (!lmc_lock_obtain("local_memcache_create", lmc->lock, &lmc->error)) 
+        goto failed;
+    if ((lmc->shm = lmc_shm_create(lmc->namespace, lmc->size, 0, e)) == NULL) 
+        goto release_and_fail;
+    lmc->base = lmc->shm->base;
+    if (is_lmc_already_initialized(lmc->base)) {
+      if (!lmc_set_lock_flag(lmc->base, e)) goto release_and_fail;
+      mem_descriptor_t *md = lmc->base;
+      lmc->va_hash = md->va_hash;
+    } else {
+      lmc_init_memory(lmc->base, lmc->size);
+      mem_descriptor_t *md = lmc->base;
+      if ((md->va_hash = ht_hash_create(lmc->base, e)) == 0) 
+          goto unlock_and_fail;
+      lmc->va_hash = md->va_hash;
+    }
+    lmc_release_lock_flag(lmc->base, e);
+    lmc_lock_release("local_memcache_create", lmc->lock, e);
+  }
+  return lmc;
+
+unlock_and_fail:
+   lmc_release_lock_flag(lmc->base, e);
+release_and_fail:
+   lmc_lock_release("local_memcache_create", lmc->lock, e);
+failed:
+  free(lmc);
+  return NULL;
+}
+
+int lmc_lock_shm_region(const char *who, local_memcache_t *lmc) {
+  if (!lmc_lock_obtain(who, lmc->lock, &lmc->error)) return 0;
+  if (!lmc_set_lock_flag(lmc->base, &lmc->error)) {
+    lmc_lock_release(who, lmc->lock, &lmc->error);
+    return 0;
+  }
+  return 1;
+}
+
+int lmc_unlock_shm_region(const char *who, local_memcache_t *lmc) {
+  int r = 1;
+  if (!lmc_release_lock_flag(lmc->base, &lmc->error)) r = 0;
+  lmc_lock_release(who, lmc->lock, &lmc->error);
+  return r;
+}
+
+char *local_memcache_get(local_memcache_t *lmc, const char *key) {
+  if (!lmc_lock_shm_region("local_memcache_get", lmc)) return 0;
+  char *r = ht_get(lmc->base, lmc->va_hash, key);
+  if (!lmc_unlock_shm_region("local_memcache_get", lmc)) return 0;
+  return r;
+}
+
+int local_memcache_set(local_memcache_t *lmc, 
+   const char *key, const char* value) {
+  if (!lmc_lock_shm_region("local_memcache_set", lmc)) return 0;
+  int r = ht_set(lmc->base, lmc->va_hash, key, value, &lmc->error);
+  if (!lmc_unlock_shm_region("local_memcache_get", lmc)) return 0;
+  return r;
+}
+
+int local_memcache_delete(local_memcache_t *lmc, char *key) {
+  if (!lmc_lock_shm_region("local_memcache_delete", lmc)) return 0;
+  int r = ht_delete(lmc->base, lmc->va_hash, key);
+  if (!lmc_unlock_shm_region("local_memcache_delete", lmc)) return 0;
+  return r;
+}
+
+int local_memcache_free(local_memcache_t *lmc) {
+  lmc_error_t e;
+  if (!lmc_lock_shm_region("local_memcache_free", lmc)) return 0;
+  int r = ht_hash_destroy(lmc->base, lmc->va_hash);
+  if (!lmc_unlock_shm_region("local_memcache_free", lmc)) return 0;
+  lmc_shm_destroy(lmc->shm, &e);
+  free(lmc->namespace);
+  free(lmc->lock);
+  return r;
+}

data/src/localmemcache.h

@@ -0,0 +1,33 @@
+#ifndef _LOCAL_MEMCACHE_INCLUDED_
+#define _LOCAL_MEMCACHE_INCLUDED_
+
+#include <stdlib.h>
+#include "lmc_hashtable.h"
+#include "lmc_shm.h"
+#include "lmc_lock.h"
+#include "lmc_error.h"
+
+#define LOCAL_MEMCACHE_FAILED 0
+#define LOCAL_MEMCACHE_SUCCESS 1
+
+typedef struct {
+  char *namespace;
+  size_t size;
+  lmc_shm_t *shm;
+  size_t va_hash;
+  lmc_lock_t *lock;
+  lmc_lock_t *root_lock;
+  void* base;
+  lmc_error_t error;
+} local_memcache_t;
+
+local_memcache_t *local_memcache_create(const char *namespace, size_t size,
+    lmc_error_t *e);
+char *local_memcache_get(local_memcache_t *lmc, const char *key);
+int local_memcache_set(local_memcache_t *lmc, const char *key, const char* value);
+int local_memcache_delete(local_memcache_t *lmc, char *key);
+int local_memcache_free(local_memcache_t *lmc);
+int local_memcache_clear_namespace(const char *namespace, int repair, 
+    lmc_error_t *e);
+
+#endif

data/src/ruby-binding/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+
+dir = File.dirname(__FILE__)
+
+$defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
+
+$srcs = ['rblocalmemcache.c']
+$objs = ['rblocalmemcache.o']
+
+$CFLAGS << " -g -I .."
+$LDFLAGS << " ../liblmc.a -lpthread -lrt "
+
+dir_config('rblocalmemcache')
+create_makefile('rblocalmemcache')

data/src/ruby-binding/localmemcache.rb

@@ -0,0 +1,32 @@
+require 'rblocalmemcache'
+
+# == Overview
+# TestRDocUsage: A useless file
+#
+# == Example
+#
+#  Usage:  ruby testRDocUsage.rb  [options]
+#
+class LocalMemCache
+
+  #  Creates a new handle for accessing a shared memory region.
+  #
+  #  LocalMemCache.new :namespace=>"foo", :size_mb=> 1
+  #
+  #  The namespace parameter is mandatory.  
+  #  The size_mb defaults to 1024 (1 GB).
+  #
+  def self.new(options)
+    o = { :size_mb => 1024 }.update(options || {})
+    raise "Missing mandatory option ':namespace'" if !o[:namespace]
+    _new(o[:namespace].gsub("/", "-"), (o[:size_mb].to_f * 1024 * 1024).to_i );
+  end
+
+  # Deletes the given namespaces, removing semaphores if necessary.
+  # Do only use if you are sure the namespace is not used anymore by other
+  # processes.
+  #
+  def self.clear_namespace(namespace, repair = false) 
+    _clear_namespace(namespace, repair)
+  end
+end

data/src/ruby-binding/rblocalmemcache.c

@@ -0,0 +1,119 @@
+/*
+ * Copyright (C) 2009, Sven C. Koehler
+ */
+
+#include <ruby.h>
+#include "localmemcache.h"
+
+/* :nodoc: */
+long long_value(VALUE i) { return NUM2LONG(rb_Integer(i)); }
+/* :nodoc: */
+VALUE num2string(long i) { return rb_big2str(rb_int2big(i), 10); }
+/* :nodoc: */
+char *rstring_ptr(VALUE s) { 
+  char* r = NIL_P(s) ? "nil" : RSTRING_PTR(rb_String(s)); 
+  return r ? r : "nil";
+}
+/* :nodoc: */
+static VALUE ruby_string(char *s) { return s ? rb_str_new2(s) : Qnil; }
+/* :nodoc: */
+int bool_value(VALUE v) { return v == Qtrue; }
+
+static VALUE LocalMemCacheError;
+
+/* :nodoc: */
+void raise_exception(VALUE error_klass, lmc_error_t *e) {
+  rb_raise(error_klass, e->error_str);
+}
+
+/* :nodoc: */
+static VALUE LocalMemCache__new2(VALUE klass, VALUE namespace, VALUE size) {
+  lmc_error_t e;
+  local_memcache_t *lmc = local_memcache_create(rstring_ptr(namespace), 
+      long_value(size), &e);
+  if (!lmc) { raise_exception(LocalMemCacheError, &e); }
+  return Data_Wrap_Struct(klass, NULL, local_memcache_free, lmc);
+}
+
+/* :nodoc: */
+static VALUE LocalMemCache__clear_namespace(VALUE klass, VALUE ns, VALUE repair) {
+  lmc_error_t e;
+  if (!local_memcache_clear_namespace(rstring_ptr(ns), bool_value(repair), &e)) {
+    raise_exception(LocalMemCacheError, &e); 
+  }
+  return Qnil;
+}
+
+/* :nodoc: */
+local_memcache_t *get_LocalMemCache(VALUE obj) {
+  local_memcache_t *lmc;
+  Data_Get_Struct(obj, local_memcache_t, lmc);
+  return lmc;
+}
+
+/* 
+ *  call-seq:
+ *     lmc.get(key)   ->   Qnil
+ *     lmc[key]       ->   Qnil
+ *
+ *  Retrieve value from hashtable.
+ */
+static VALUE LocalMemCache__get(VALUE obj, VALUE key) {
+  return ruby_string(local_memcache_get(get_LocalMemCache(obj), 
+      rstring_ptr(key)));
+}
+
+/* 
+ *  call-seq:
+ *     lmc.set(key, value)   ->   Qnil
+ *     lmc[key]=value        ->   Qnil
+ *
+ *  Set value for key in hashtable.
+ */
+
+static VALUE LocalMemCache__set(VALUE obj, VALUE key, VALUE value) {
+  local_memcache_t *lmc = get_LocalMemCache(obj);
+  if (!local_memcache_set(lmc, rstring_ptr(key), rstring_ptr(value))) { 
+    raise_exception(LocalMemCacheError, &lmc->error); 
+  }
+  return Qnil;
+}
+
+/* 
+ *  call-seq:
+ *     lmc.delete(key)   ->   Qnil
+ *
+ *  Deletes key from hashtable.
+ */
+static VALUE LocalMemCache__delete(VALUE obj, VALUE key) {
+  return local_memcache_delete(get_LocalMemCache(obj), 
+      rstring_ptr(key));
+  return Qnil;
+}
+
+/* 
+ *  call-seq:
+ *     lmc.close()   ->   Qnil
+ *
+ *  Releases hashtable.
+ */
+static VALUE LocalMemCache__close(VALUE obj) {
+  local_memcache_free(get_LocalMemCache(obj));
+  return Qnil;
+}
+
+static VALUE LocalMemCache;
+
+void Init_rblocalmemcache() {
+  LocalMemCacheError = rb_define_class("LocalMemCacheError", rb_eStandardError);
+  LocalMemCache = rb_define_class("LocalMemCache", rb_cObject);
+  rb_define_singleton_method(LocalMemCache, "_new", LocalMemCache__new2, 2);
+  rb_define_singleton_method(LocalMemCache, "_clear_namespace", 
+      LocalMemCache__clear_namespace, 2);
+  rb_define_method(LocalMemCache, "get", LocalMemCache__get, 1);
+  rb_define_method(LocalMemCache, "[]", LocalMemCache__get, 1);
+  rb_define_method(LocalMemCache, "delete", LocalMemCache__delete, 1);
+  rb_define_method(LocalMemCache, "set", LocalMemCache__set, 2);
+  rb_define_method(LocalMemCache, "[]=", LocalMemCache__set, 2);
+  rb_define_method(LocalMemCache, "close", LocalMemCache__close, 0);
+}

data/src/tests/alloc

@@ -0,0 +1,11 @@
+#! /bin/sh
+D=`dirname $0`
+DIR=`cd $D; pwd`
+script=$DIR/alloc.rb
+
+if test "x$1" = "x-d"; then
+  irb -r $script
+else
+  #valgrind --leak-check=full --tool=memcheck ruby $script
+  time ruby $script
+fi