localmemcache 0.2.0 → 0.2.1

data/.gitignore

@@ -13,5 +13,7 @@ config.log
 lmc_config.h
 Makefile
 *.so
+*.bundle
+*.log
 pkg
 

data/README

@@ -19,6 +19,8 @@ SUPPORTED SYSTEMS
 - A CPU architecture with more than 32 bits is recommended, since otherwise you
   might run out of virtual address space when you use larger shared memory
   segments.
+- OS X is not supported, because it doesn't have sem_timedwait() and
+  sem_getvalue().
 
 EXAMPLE
 =======

data/Rakefile

@@ -24,6 +24,14 @@ task :changelog do
   }
 end
 
+task :sanity_test do
+  sh "./configure && make -C src clean && make -C src && " +
+      "(cd src/ruby-binding; ruby extconf.rb) && " +
+      "make -C src/ruby-binding/ && " +
+      "(cd src/tests; ruby extconf.rb) && " +
+      "make -C src/tests/ && ./src/tests/lmc "
+end
+
 task :c_api_package do
   tgz = "pkg/localmemcache-#{version}.tar.gz"
   sh "test -d pkg || mkdir pkg"
@@ -36,7 +44,7 @@ task :pushsite do
   sh "chmod 755 site"
   sh "chmod 644 site/*.html"
   sh "chmod 644 site/*.css"
-  sh 'rsync --rsh="ssh -i $HOME/.ssh/id_rsa_projects -l sck" -avz site/ sck@localmemcache.rubyforge.org:/var/www/gforge-projects/localmemcache/'
+  sh 'rsync --rsh="ssh -i $HOME/.ssh/id_rsa_oss -l sck" -avz site/ sck@localmemcache.rubyforge.org:/var/www/gforge-projects/localmemcache/'
 end
 
 begin

data/VERSION

@@ -1 +1 @@
-0.2.0
+0.2.1

data/configure

@@ -600,6 +600,7 @@ PACKAGE_BUGREPORT=
 
 ac_unique_file="${srcdir}/src/lmc_config.h.in"
 ac_default_prefix=$prefix
+ac_default_prefix=$prefix
 ac_subst_vars='SHELL
 PATH_SEPARATOR
 PACKAGE_NAME
@@ -2754,6 +2755,21 @@ fi
 
 
 
+{ $as_echo "$as_me:$LINENO: checking for apple OS X" >&5
+$as_echo_n "checking for apple OS X... " >&6; }
+if test "x`uname`" = "xDarwin" && test "x$LMC_FORCE_BUILD" = "x"; then
+  echo ""
+  echo "->  Apple OS X is not supported because it doesn't have "
+  echo "    sem_getvalue and sem_timedwait!"
+  echo "    You may set the environment variable LMC_FORCE_BUILD "
+  echo "    to build a version of localmemcache that cannot recover "
+  echo "    from crashes."
+  exit 2;
+fi
+{ $as_echo "$as_me:$LINENO: result: Ok" >&5
+$as_echo "Ok" >&6; }
+
+
 { $as_echo "$as_me:$LINENO: checking version" >&5
 $as_echo_n "checking version... " >&6; }
 VERSION=`cat ${srcdir}/VERSION`
@@ -2785,11 +2801,32 @@ env > /tmp/lmc.env
 { $as_echo "$as_me:$LINENO: result: $PREFIX" >&5
 $as_echo "$PREFIX" >&6; }
 
+{ $as_echo "$as_me:$LINENO: checking installation directory prefix" >&5
+$as_echo_n "checking installation directory prefix... " >&6; }
+
+if test "$prefix" = "NONE"; then
+    if test "x$PREFIX" != "x" ; then
+  prefix=$PREFIX
+    else
+  prefix=/usr/local
+    fi
+fi
+
+PREFIX=$ac_default_prefix
+PREFIX=$prefix
+exec_prefix=$PREFIX
+
+{ $as_echo "$as_me:$LINENO: result: $PREFIX" >&5
+$as_echo "$PREFIX" >&6; }
+
+{ $as_echo "$as_me:$LINENO: checking if inside RubyGems" >&5
+$as_echo_n "checking if inside RubyGems... " >&6; }
+env > /tmp/lmc.env
+{ $as_echo "$as_me:$LINENO: result: $PREFIX" >&5
+$as_echo "$PREFIX" >&6; }
+
 
 
-#--------------------------------------------------------------------
-# Propagate prefix argument as installation directory.
-#--------------------------------------------------------------------
 
 
 
@@ -3230,8 +3267,8 @@ _ACEOF
 
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 # Files that config.status was made for.
-config_files="`echo $ac_config_files`"
-config_headers="`echo $ac_config_headers`"
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
 
 _ACEOF
 
@@ -4459,8 +4496,8 @@ _ACEOF
 
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 # Files that config.status was made for.
-config_files="`echo $ac_config_files`"
-config_headers="`echo $ac_config_headers`"
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
 
 _ACEOF
 

data/configure.in

@@ -5,6 +5,19 @@ AC_SUBST(CC)
 AC_PROG_RANLIB
 AC_SUBST(RANLIB)
 
+AC_MSG_CHECKING([for apple OS X])
+if test "x`uname`" = "xDarwin" && test "x$LMC_FORCE_BUILD" = "x"; then
+  echo ""
+  echo "->  Apple OS X is not supported because it doesn't have "
+  echo "    sem_getvalue and sem_timedwait!"
+  echo "    You may set the environment variable LMC_FORCE_BUILD "
+  echo "    to build a version of localmemcache that cannot recover "
+  echo "    from crashes."
+  exit 2;
+fi
+AC_MSG_RESULT([Ok])
+
+
 AC_MSG_CHECKING([version])
 VERSION=`cat ${srcdir}/VERSION`
 AC_SUBST(VERSION)
@@ -30,11 +43,28 @@ AC_MSG_CHECKING([if inside RubyGems])
 env > /tmp/lmc.env
 AC_MSG_RESULT([$PREFIX])
 
+AC_MSG_CHECKING([installation directory prefix])
+
+if test "$prefix" = "NONE"; then 
+    if test "x$PREFIX" != "x" ; then
+  prefix=$PREFIX
+    else
+  prefix=/usr/local
+    fi
+fi
+AC_PREFIX_DEFAULT($prefix)
+PREFIX=$ac_default_prefix
+PREFIX=$prefix
+exec_prefix=$PREFIX
+AC_SUBST(PREFIX)
+AC_MSG_RESULT([$PREFIX])
+
+AC_MSG_CHECKING([if inside RubyGems])
+env > /tmp/lmc.env
+AC_MSG_RESULT([$PREFIX])
+
 
 
-#--------------------------------------------------------------------
-# Propagate prefix argument as installation directory.
-#--------------------------------------------------------------------
 AC_SUBST(PREFIX)
 
 

data/site/index.html

@@ -7,9 +7,44 @@
   <body>  
 
 <div id="content">
-<h1>Efficiently sharing a hashtable between processes on a local Unix machine.</h1>
+<h1>The beauty of memcached.&nbsp;&nbsp;For local data.&nbsp;&nbsp;Blazingly fast.</h1>
 
-<p><b>Localmemcache</b> aims to be faster than using <a href="http://www.danga.com/memcached/">memcached</a> locally by using shared memory and providing a similar interface for Ruby and C.
+<p><b>Localmemcache</b> is a library for C and ruby that aims to provide
+an interface similar to memcached but for accessing local data instead of
+remote data.  It's based on <b>mmap()</b>'ed shared memory for maximum speed.
+
+<h2>Changes for 0.2.1</h2>
+
+<li>Fixed a bug that prevented setting values in the hashtable</li>
+<li>Accessing a closed memory cache does no longer result in a crash</li>
+<li><b>Speed improvements</b>: On my machine localmemcache is now only
+about <b>20</b>% slower than Ruby's hash (<b>0.2.0</b> was about 
+<b>40</b>% slower)</li>
+<li><b>OS X is now officially not supported</b> as it lacks sem_timedwait and
+sem_getvalue (You still can force a build but it won't be able to
+recover from crashes.)</li>
+<li>The environment variable <b>LMC_NAMESPACES_ROOT_PATH</b> can now be
+used to override the default, which is <b>/var/tmp/localmemcache</b></li>
+
+
+<h2>New features in 0.2.0</h2>
+
+<li><b>Logging</b>: In case your application is terminated while
+accessing the shared memory (eg by <b>kill -9</b>), it is now able to
+<b>restore the integrity of your data</b>.</li>
+<li><b>\0 character</b> can now be used in <b>keys</b> and
+<b>values</b></li>
+<li>The ruby binding now features a <b>keys()</b> method.</b>
+<li>Added a <b>C API</b>.  See <a href="http://github.com/sck/localmemcache/blob/8c753f74c53b107d271975bedcc1f91a3dbd6961/src/localmemcache.h">localmemcache.h</a></li>
+
+<h2>Supported Systems</h2>
+
+<li>Unix (for <b>mmap())</b></li>
+<li>OS X is currently not supported because it doesn't have
+sem_timedwait() and sem_getvalue()</li>
+<li>A CPU architecture with more than <b>32 bits</b> is recommended, since
+otherwise you might run out of virtual address space when you use larger
+shared memory segments.</li>
 
 <h2>Install</h2>
 
@@ -18,6 +53,8 @@
 <pre><code>gem install localmemcache
 </code></pre>
 
+If you just want to use the <b>C API</b>, download the .tar.gz from <a href="http://rubyforge.org/frs/?group_id=7925">here</a>.
+
 <h2>Using</h2>
 <p><pre><code>require 'localmemcache'
 $lm = LocalMemCache.new :namespace => :viewcounters
@@ -25,6 +62,7 @@ $lm[:foo] = 1
 $lm[:foo]
 $lm.delete(:foo)
 </code></pre> 
+(C version of this example: <a href="http://github.com/sck/localmemcache/blob/8c753f74c53b107d271975bedcc1f91a3dbd6961/example/hello.c">hello.c</a>)
 </p>
 <a href="http://github.com/sck/localmemcache/tree/master">Read more</a>.
 
@@ -32,7 +70,7 @@ $lm.delete(:foo)
 
 <p>Here's a quick speed comparison, made on an 
 <b>Intel(R) Xeon(R) CPU E5205 @ 1.86GHz</b>:</p>
-Benchmark pseudo code:
+Ruby benchmark pseudo code:
 <pre><code>2_000_000.times {
   index = rand(10000).to_s
   $hash.set(index, index)
@@ -41,13 +79,14 @@ Benchmark pseudo code:
 </code></pre>
 
 <pre>
-MemCache:      <b>253,326.122</b> ms
-LocalMemCache: <b>6,055.552</b> ms
-Ruby's Hash:   <b>4,963.313</b> ms
+MemCache:            <b>253,326.122</b> ms
+LocalMemCache 0.2.1: <b>5,799.225</b> ms
+Ruby's Hash:         <b>4,963.313</b> ms
 </pre>
 
-<b>Localmemcache</b> is about <b>40</b> times faster than using memcached
-locally, and about <b>20%</b> slower than Ruby's hash.
+So, on my machine <b>Localmemcache</b> 0.2.1 is about <b>43</b> times
+faster than using memcached locally, and about <b>20</b>% slower than
+Ruby's hash.
 
 <h2>Source code</h2>
 
@@ -57,6 +96,11 @@ can be retrieved by executing</p>
 <pre><code>git clone git://github.com/sck/localmemcache.git
 </code></pre>
 
+<h2>Read on</h2>
+
+A bit of documenation on how <b>localmemcache</b> <a
+href="http://github.com/sck/localmemcache/blob/96b5e0863e1da7f17e249a6c8884984e0c23ee2f/INTERNALS">works</a>.
+
 <h2>License</h2>
 
 <p>Copyright (c) 2009 Sven C. Koehler (schween at s n a f u dot de)<br>

data/src/lmc_hashtable.c

@@ -31,10 +31,10 @@ unsigned long ht_hash_key(const char *s, size_t l) {
   unsigned long v;
   size_t i;
   for (v = 0, i = 0; i++ < l; s++) { v = *s + 31 * v; }
-  return v % HT_BUCKETS;
+  return v % LMC_HT_BUCKETS;
 }
 
-ht_hash_entry_t null_node = { 0, 0, 0 };
+ht_hash_entry_t lmc_null_node = { 0, 0, 0 };
 
 va_ht_hash_t ht_hash_create(void *base, lmc_error_t *e) {
   va_ht_hash_t va_ht = lmc_valloc(base, sizeof(ht_hash_t));
@@ -54,7 +54,7 @@ int ht_hash_destroy(void *base, va_ht_hash_t ht) {
 ht_hash_entry_t *ht_lookup(void *base, va_ht_hash_t va_ht, const char *key, 
     size_t n_key) {
   va_ht_hash_entry_t va_hr;
-  ht_hash_entry_t *hr ;
+  ht_hash_entry_t *hr = &lmc_null_node;
   ht_hash_t *ht = base + va_ht;
   size_t i;
   for (va_hr = ht->va_buckets[ht_hash_key(key, n_key)]; 
@@ -73,7 +73,7 @@ ht_hash_entry_t *ht_lookup(void *base, va_ht_hash_t va_ht, const char *key,
 next:
     va_hr = hr->va_next;
   }
-  return &null_node;
+  return &lmc_null_node;
 }
 
 ht_hash_entry_t *ht_lookup2(void *base, va_ht_hash_t va_ht, char *k) {
@@ -112,14 +112,12 @@ int ht_set(void *base, va_ht_hash_t va_ht, const char *key,
   ht_hash_entry_t *hr = ht_lookup(base, va_ht, key, n_key);
   unsigned v;
   if (hr->va_key == 0) {
-    int free_key = 1;
     lmc_log_ht_set *l = (lmc_log_ht_set *)lmc_log_op(base, LMC_OP_HT_SET);
     if ((l->va_value = lmc_ht_strdup(base, value, n_value)) == 0 ||
         (l->va_key = lmc_ht_strdup(base, key, n_key)) == 0) {
       LMC_MEMORY_POOL_FULL("ht_set");
       goto failed;
     }
-    free_key = 0;
     va_ht_hash_entry_t va = lmc_valloc(base, sizeof(ht_hash_entry_t));
     hr = va ? base + va : 0;
     if (hr == NULL) { 
@@ -133,12 +131,6 @@ int ht_set(void *base, va_ht_hash_t va_ht, const char *key,
     hr->va_next = ht->va_buckets[v];
     ht->va_buckets[v] = va;
     hr->va_value = l->va_value;
-    if (free_key) {
-      size_t va = l->va_key;
-      l->op_id = 0;
-      LMC_TEST_CRASH
-      lmc_free(base, va);
-    }
     lmc_log_finish(base);
   } else {
     LMC_TEST_CRASH
@@ -159,7 +151,7 @@ failed_no_log:
 
 int ht_delete(void *base, va_ht_hash_t va_ht, const char *key, size_t n_key) {
   va_ht_hash_entry_t va_hr;
-  ht_hash_entry_t *hr;
+  ht_hash_entry_t *hr = &lmc_null_node;
   size_t va_p = 0;
   ht_hash_t *ht = base + va_ht;
   size_t i;
@@ -190,12 +182,13 @@ int ht_delete(void *base, va_ht_hash_t va_ht, const char *key, size_t n_key) {
   return 0;
 }
 
-int ht_hash_iterate(void *base, va_ht_hash_t va_ht, void *ctx, ITERATOR_P(iter)) {
+int ht_hash_iterate(void *base, va_ht_hash_t va_ht, void *ctx, 
+    LMC_ITERATOR_P(iter)) {
   va_ht_hash_entry_t va_hr;
-  ht_hash_entry_t *hr;
+  ht_hash_entry_t *hr = &lmc_null_node;
   ht_hash_t *ht = base + va_ht;
   size_t k;
-  for (k = 0; k < HT_BUCKETS; k++) {
+  for (k = 0; k < LMC_HT_BUCKETS; k++) {
     for (va_hr = ht->va_buckets[k]; va_hr != 0 && hr != NULL; 
         va_hr = hr->va_next) {
       hr = va_hr ? base + va_hr : 0;
@@ -209,19 +202,21 @@ int ht_check_memory(void *base, va_ht_hash_t va_ht) {
   char *bf = lmc_um_new_mem_usage_bitmap(base);
   if (!bf) return 0;
   va_ht_hash_entry_t va_hr;
-  ht_hash_entry_t *hr;
+  ht_hash_entry_t *hr = &lmc_null_node;
   ht_hash_t *ht = base + va_ht;
   if (!lmc_um_mark_allocated(base, bf, va_ht)) goto failed;
   size_t k;
-  for (k = 0; k < HT_BUCKETS; k++) {
+  for (k = 0; k < LMC_HT_BUCKETS; k++) {
     for (va_hr = ht->va_buckets[k]; va_hr != 0 && hr != NULL; 
         va_hr = hr->va_next) {
       hr = va_hr ? base + va_hr : 0;
-      if (!hr) continue;
+      if (!hr) goto next_bucket;
       if (!(lmc_um_mark_allocated(base, bf, va_hr) &&
           lmc_um_mark_allocated(base, bf, hr->va_key) &&
           lmc_um_mark_allocated(base, bf, hr->va_value))) goto failed;
     }
+  next_bucket:
+    continue;
   }
   lmc_um_find_leaks(base, bf);
   free(bf);

data/src/lmc_hashtable.h

@@ -16,12 +16,13 @@ typedef struct {
   va_string_t va_value;
 } ht_hash_entry_t;
 
-#define HT_BUCKETS 499
-#define ITERATOR_P(n) int ((n)) (void *ctx, const char *key, const char *value)
+#define LMC_HT_BUCKETS 499
+#define LMC_ITERATOR_P(n) int ((n)) \
+    (void *ctx, const char *key, const char *value)
 
 typedef size_t va_ht_hash_t;
 typedef struct {
-  va_ht_hash_entry_t va_buckets[HT_BUCKETS];
+  va_ht_hash_entry_t va_buckets[LMC_HT_BUCKETS];
 } ht_hash_t;
 
 va_ht_hash_t ht_hash_create(void *base, lmc_error_t *e);
@@ -33,7 +34,8 @@ const char *ht_get(void *base, va_ht_hash_t va_ht, const char *key, size_t n_key
     size_t *n_value); 
 int ht_delete(void *base, va_ht_hash_t va_ht, const char *key, size_t n_key);
 int ht_hash_destroy(void *base, va_ht_hash_t ht);
-int ht_hash_iterate(void *base, va_ht_hash_t ht, void *ctx, ITERATOR_P(iter));
+int ht_hash_iterate(void *base, va_ht_hash_t ht, void *ctx, 
+    LMC_ITERATOR_P(iter));
 
 int ht_check_memory(void *base, va_ht_hash_t va_ht);
 int ht_redo(void *base, va_ht_hash_t va_ht, lmc_log_descriptor_t *l, 

data/src/lmc_lock.c

@@ -9,21 +9,13 @@
 #include <time.h>
 #include "lmc_lock.h"
 
-int c_l(lmc_lock_t *l, lmc_error_t *e) { 
-  if (!l) { 
-    lmc_handle_error_with_err_string("check_lock",
-        "Semaphore not initialized", "LocalMemCacheError", e);
-  }
-  return l != NULL; 
-}
-
 lmc_lock_t *lmc_lock_init(const char *namespace, int init, lmc_error_t *e) {
   lmc_lock_t *l = malloc(sizeof(lmc_lock_t));
   if (!l) return NULL;
   strncpy((char *)&l->namespace, namespace, 1023);
   
-  lmc_handle_error((l->sem = sem_open(l->namespace, O_CREAT, 0600, init)) == NULL,
-      "sem_open", "LockError", e);
+  lmc_handle_error((l->sem = sem_open(l->namespace, O_CREAT, 0600, init)) == 
+      NULL, "sem_open", "LockError", e);
   if (!l->sem) { free(l); return NULL; }
   return l;
 }
@@ -31,16 +23,12 @@ lmc_lock_t *lmc_lock_init(const char *namespace, int init, lmc_error_t *e) {
 int lmc_clear_namespace_lock(const char *namespace) {
   lmc_error_t e;
   lmc_lock_t *l = lmc_lock_init(namespace, 1, &e);
-  //printf("clear_namespace locks: %s %d\n", namespace, lmc_lock_get_value(l));
   lmc_lock_repair(l);
-  //printf("AFTER clear_namespace locks: %s %d\n", namespace, 
-      //lmc_lock_get_value(l));
   free(l);
   return 1;
 }
 
 int lmc_is_locked(lmc_lock_t* l, lmc_error_t *e) {
-  if (!c_l(l, e)) { return 0; }
   if (sem_trywait(l->sem) == -1) {
     return 1;
   } else {
@@ -50,6 +38,9 @@ int lmc_is_locked(lmc_lock_t* l, lmc_error_t *e) {
 }
 
 int lmc_sem_timed_wait(lmc_lock_t* l) {
+#ifdef __APPLE__
+  return sem_wait(l->sem);
+#else
   struct timespec ts;
   clock_gettime(CLOCK_REALTIME, &ts);
 #ifdef DO_TEST_CRASH
@@ -58,17 +49,21 @@ int lmc_sem_timed_wait(lmc_lock_t* l) {
   ts.tv_sec += 2;
 #endif
   return sem_timedwait(l->sem, &ts);
+#endif
 }
 
 int lmc_sem_timed_wait_mandatory(lmc_lock_t* l) {
+#ifdef __APPLE__
+  return sem_wait(l->sem);
+#else
   struct timespec ts;
   clock_gettime(CLOCK_REALTIME, &ts);
   ts.tv_sec += 20;
   return sem_timedwait(l->sem, &ts);
+#endif
 }
 
 int lmc_is_lock_working(lmc_lock_t* l, lmc_error_t *e) {
-  if (!c_l(l, e)) { return 0; }
   if (lmc_sem_timed_wait(l) == -1) {
     return 0;
   } else {
@@ -78,6 +73,9 @@ int lmc_is_lock_working(lmc_lock_t* l, lmc_error_t *e) {
 }
 
 void lmc_lock_repair(lmc_lock_t *l) {
+#ifdef __APPLE__
+  return;
+#else
   int v; 
   sem_getvalue(l->sem, &v);
   if (v == 0) { 
@@ -88,6 +86,7 @@ void lmc_lock_repair(lmc_lock_t *l) {
     sem_wait(l->sem); 
     sem_getvalue(l->sem, &v);
   }
+#endif
 }
 
 int lmc_lock_get_value(lmc_lock_t* l) {
@@ -97,7 +96,7 @@ int lmc_lock_get_value(lmc_lock_t* l) {
 }
 
 int lmc_lock_obtain(const char *where, lmc_lock_t* l, lmc_error_t *e) {
-  if (!c_l(l,e)) { return 0; }
+  if (sem_trywait(l->sem) != -1) { return 1; }
   int r = lmc_sem_timed_wait(l);
   if (r == -1 && errno == ETIMEDOUT) {
     lmc_handle_error_with_err_string("sem_timedwait", strerror(errno), 
@@ -114,10 +113,9 @@ int lmc_lock_obtain_mandatory(const char *where, lmc_lock_t* l, lmc_error_t *e)
         "LockTimedOut", e);
     return 0;
   }
-  return c_l(l,e) && lmc_handle_error(r, "sem_wait", "LockError", e);
+  return lmc_handle_error(r, "sem_wait", "LockError", e);
 }
 
 int lmc_lock_release(const char *where, lmc_lock_t* l, lmc_error_t *e) {
-  return c_l(l, e) && lmc_handle_error(sem_post(l->sem) == -1, "sem_post", 
-      "LockError", e);
+  return lmc_handle_error(sem_post(l->sem) == -1, "sem_post", "LockError", e);
 }

data/src/lmc_shm.c

@@ -13,7 +13,11 @@
 
 #include "lmc_shm.h"
 
-#define LMC_SHM_ROOT_PATH "/var/tmp/localmemcache"
+const char *lmc_namespace_root_path() {
+  const char *ep = getenv("LMC_NAMESPACES_ROOT_PATH");
+  if (ep) { return ep; }
+  return "/var/tmp/localmemcache";
+}
 
 int lmc_does_file_exist(const char *fn) {
   struct stat st;
@@ -27,13 +31,13 @@ int lmc_file_size(const char *fn) {
 }
 
 void lmc_shm_ensure_root_path() {
-  if (!lmc_does_file_exist(LMC_SHM_ROOT_PATH)) {
-    mkdir(LMC_SHM_ROOT_PATH, 01777);
+  if (!lmc_does_file_exist(lmc_namespace_root_path())) {
+    mkdir(lmc_namespace_root_path(), 01777);
   }
 }
 
 void lmc_file_path_for_namespace(char *result, const char *ns) {
-  snprintf(result, 1023, "%s/%s.lmc", LMC_SHM_ROOT_PATH, ns);
+  snprintf(result, 1023, "%s/%s.lmc", lmc_namespace_root_path(), ns);
 }
 
 int lmc_does_namespace_exist(const char *ns) {

data/src/lmc_valloc.c

@@ -69,7 +69,8 @@ lmc_mem_status_t lmc_status(void *base, char *where) {
   ms.total_mem = md->total_size;
   while (c) { 
     if (!lmc_is_va_valid(base, (void *)c - base)) {
-      printf("[%s] invalid pointer detected: %ld...\n", where, (void *)c - base);
+      printf("lmc: [%s] invalid pointer detected: %zd...\n", where, 
+          (void *)c - base);
       lmc_dump(base);
       abort();
     }
@@ -105,7 +106,6 @@ int is_lmc_already_initialized(void *base) {
 void lmc_init_memory(void *ptr, size_t size) {
   lmc_mem_descriptor_t *md = ptr;
   size_t s = size - sizeof(lmc_mem_descriptor_t);
-  // size: enough space for lmc_mem_descriptor_t + lmc_mem_chunk_descriptor_t
   md->first_free = sizeof(lmc_mem_descriptor_t);
   md->magic = 0xF00D;
   md->locked = 0;
@@ -122,10 +122,10 @@ size_t lmc_max(size_t a, size_t b) {
 size_t __s(char *where, lmc_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); }
+  if (mem_before) { printf("[%zd:%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, 
+    printf("expected_diff (%zu) != diff (%zd)\n", expected_diff, 
         free - mem_before);
     abort();
   }
@@ -134,10 +134,9 @@ size_t __s(char *where, lmc_mem_status_t ms, size_t mem_before, size_t expected_
 
 size_t lmc_valloc(void *base, size_t size) {
   lmc_mem_descriptor_t *md = base;
-  // idea: MOD by power of 2
+  // consider: make size divisible by power of 2
   size_t s = lmc_max(size + sizeof(size_t), 
       sizeof(lmc_mem_chunk_descriptor_t) + sizeof(size_t));
-  // larger than available space?
   lmc_mem_chunk_descriptor_t *c = md_first_free(base);
   lmc_mem_chunk_descriptor_t *p = NULL;
   if (size == 0) { return 0; }
@@ -150,7 +149,6 @@ size_t lmc_valloc(void *base, size_t size) {
     c = base + c->next; 
   }
   if (!c) {
-    //fprintf(stderr, "lmc_valloc: Failed to allocate %d bytes!\n", size);
     return 0;
   }
   size_t r = 0;
@@ -176,8 +174,7 @@ size_t lmc_valloc(void *base, size_t size) {
   return r + sizeof(size_t);
 }
 
-// compact_chunks, 
-void lmc_check_coalesce(void *base, size_t va_chunk) {
+void lmc_compact_free_chunks(void *base, size_t va_chunk) {
   lmc_mem_descriptor_t *md = base;
   lmc_mem_chunk_descriptor_t *chunk = base + va_chunk;
   size_t c_size = chunk->size;
@@ -272,7 +269,7 @@ void __lmc_free(void *base, size_t va_used_chunk, size_t uc_size) {
       LMC_TEST_CRASH
       c_free_chunk->size += uc_size;
       LMC_TEST_CRASH
-      lmc_check_coalesce(base, va_c_free_chunk);
+      lmc_compact_free_chunks(base, va_c_free_chunk);
       break;
     } else 
     // ---------------------- 
@@ -286,7 +283,7 @@ void __lmc_free(void *base, size_t va_used_chunk, size_t uc_size) {
       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);
+      lmc_compact_free_chunks(base, va_used_chunk);
       break;
     }
     if (va_used_chunk >= va_c_free_chunk && va_used_chunk <= va_c_free_end) {
@@ -331,11 +328,6 @@ void lmc_free(void *base, size_t chunk) {
   __lmc_free(base, va_used_chunk, uc_size);
 }
 
-void lmc_realloc(void *base, size_t chunk) {
-  // check if enough reserved space, true: resize; otherwise: alloc new and 
-  // then free
-}
-
 int lmc_um_getbit(char *bf, int i) {
   bf += i / 8; return (*bf & (1 << (i % 8))) != 0;
 }
@@ -349,7 +341,6 @@ void lmc_um_setbit(char *bf, int i, int v) {
 int lmc_um_find_leaks(void *base, char *bf) {
   lmc_mem_descriptor_t *md = base;
   size_t i;
-  // check if gap size if smaller than sizeof(free_chunk_t)
   int gap = 0;
   size_t gs = 0;
   size_t m;
@@ -382,7 +373,6 @@ int lmc_um_find_leaks(void *base, char *bf) {
     space += i - gs;
     __lmc_free(base, gs, i - gs);
   }
-  //printf("total leaks: %zd block, %zd bytes total\n", gap_count, space);
   return 1;
 }
 
@@ -396,17 +386,7 @@ int lmc_um_check_unmarked(void *base, char *bf, size_t va, size_t size) {
     while (*b == n && i < end - sizeof(size_t)) { 
       i += sizeof(size_t) * 8; b++; 
     }
-    if (lmc_um_getbit(bf, i) != 0) {
-      //printf("umarked2: FAILED at: %zd\n", i);
-      //printf("umarked2: FAILED start: %zd\n", va);
-      //size_t d = i;
-      //while (lmc_um_getbit(bf, d) != 0) { --d; }
-      //printf("area starts at: %zd\n", d);
-      //size_t e = i;
-      //while (lmc_um_getbit(bf, e) != 0) { ++e; }
-      //printf("area ends at: %zd\n", e);
-      return 0;
-    }
+    if (lmc_um_getbit(bf, i) != 0) { return 0; }
   }
   return 1;
 }
@@ -416,7 +396,7 @@ int lmc_um_mark(void *base, char *bf, size_t va, size_t size) {
   lmc_mem_descriptor_t *md = base;
   if ((va > sizeof(lmc_mem_descriptor_t)) &&
       (!lmc_is_va_valid(base, va) || !lmc_is_va_valid(base, va + size))) {
-    printf("Error: VA start out of range: va: %zd - %zd max %zd!\n", 
+    printf("lmc: Error: VA start out of range: va: %zd - %zd max %zd!\n", 
         va, va + size, md->total_size);
     return 0;
   }

data/src/localmemcache.c

@@ -284,7 +284,8 @@ int local_memcache_free(local_memcache_t *lmc, lmc_error_t *e) {
   return r;
 }
 
-int local_memcache_iterate(local_memcache_t *lmc, void *ctx, ITERATOR_P(iter)) {
+int local_memcache_iterate(local_memcache_t *lmc, void *ctx, 
+    LMC_ITERATOR_P(iter)) {
   if (!lmc_lock_shm_region("local_memcache_iterate", lmc)) return 0;
   int r = ht_hash_iterate(lmc->base, lmc->va_hash, ctx, iter);
   if (!lmc_unlock_shm_region("local_memcache_iterate", lmc)) return 0;

data/src/localmemcache.h

@@ -34,7 +34,8 @@ int local_memcache_set(local_memcache_t *lmc, const char *key, size_t n_key,
     const char* value, size_t n_value);
 int local_memcache_delete(local_memcache_t *lmc, char *key, size_t n_key);
 int local_memcache_free(local_memcache_t *lmc, lmc_error_t *e);
-int local_memcache_iterate(local_memcache_t *lmc, void *ctx, ITERATOR_P(iter));
+int local_memcache_iterate(local_memcache_t *lmc, void *ctx, 
+    LMC_ITERATOR_P(iter));
 int local_memcache_clear_namespace(const char *namespace, int repair, 
     lmc_error_t *e);
 int local_memcache_check_namespace(const char *namespace, lmc_error_t *e);

data/src/ruby-binding/extconf.rb

@@ -8,7 +8,11 @@ $srcs = ['rblocalmemcache.c']
 $objs = ['rblocalmemcache.o']
 
 $CFLAGS << " -g -I .."
-$LDFLAGS << " ../liblmc.a -lpthread -lrt "
+$LDFLAGS << " -lpthread "
+$LOCAL_LIBS << "../liblmc.a"
+if have_library("rt")
+  $LDFLAGS << " -lrt"
+end
 
 dir_config('rblocalmemcache')
 create_makefile('rblocalmemcache')

data/src/ruby-binding/localmemcache.rb

@@ -18,6 +18,7 @@ class LocalMemCache
   class RecoveryFailed < LocalMemCacheError; end
   class ShmLockFailed < LocalMemCacheError; end
   class ShmUnlockFailed < LocalMemCacheError; end
+  class MemoryPoolClosed < LocalMemCacheError; end
 
   #  Creates a new handle for accessing a shared memory region.
   #

data/src/ruby-binding/rblocalmemcache.c

@@ -5,6 +5,14 @@
 #include <ruby.h>
 #include "localmemcache.h"
 
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+
 /* :nodoc: */
 long long_value(VALUE i) { return NUM2LONG(rb_Integer(i)); }
 /* :nodoc: */
@@ -17,6 +25,7 @@ char *rstring_ptr(VALUE s) {
   return r ? r : "nil";
 }
 
+/* :nodoc: */
 size_t rstring_length(VALUE s) { 
   size_t r = NIL_P(s) ? 0 : RSTRING_LEN(rb_String(s)); 
   return r;
@@ -26,39 +35,78 @@ static VALUE ruby_string(const char *s) { return s ? rb_str_new2(s) : Qnil; }
 /* :nodoc: */
 int bool_value(VALUE v) { return v == Qtrue; }
 
+/* :nodoc: */
 static VALUE lmc_ruby_string2(const char *s, size_t l) { 
   return s ? rb_str_new(s, l) : Qnil; 
 }
 
+/* :nodoc: */
 static VALUE lmc_ruby_string(const char *s) { 
   return lmc_ruby_string2(s + sizeof(size_t), *(size_t *) s);
 }
 
+typedef struct {
+  local_memcache_t *lmc;
+  int open;
+} rb_lmc_handle_t;
 
 static VALUE LocalMemCache;
 
 /* :nodoc: */
-void raise_exception(lmc_error_t *e) {
-  VALUE eid = rb_intern(e->error_type);
+void __rb_lmc_raise_exception(const char *error_type, const char *m) {
+  VALUE eid = rb_intern(error_type);
   VALUE k = rb_const_get(LocalMemCache, eid);
-  rb_raise(k, e->error_str);
+  rb_raise(k, m);
+}
+
+/* :nodoc: */
+void rb_lmc_raise_exception(lmc_error_t *e) {
+  __rb_lmc_raise_exception(e->error_type, e->error_str);
+}
+
+/* :nodoc: */
+local_memcache_t *rb_lmc_check_handle_access(rb_lmc_handle_t *h) {
+  if (!h || (h->open == 0) || !h->lmc) {
+    __rb_lmc_raise_exception("MemoryPoolClosed", "Pool is closed");
+    return 0;
+  }
+  return h->lmc;
+}
+
+/* :nodoc: */
+static void rb_lmc_free_handle(rb_lmc_handle_t *h) {
+  lmc_error_t e;
+  local_memcache_free(rb_lmc_check_handle_access(h), &e);
 }
 
+
 /* :nodoc: */
 static VALUE LocalMemCache__new2(VALUE klass, VALUE namespace, VALUE size_mb) {
   lmc_error_t e;
-  local_memcache_t *lmc = local_memcache_create(rstring_ptr(namespace), 
+  local_memcache_t *l = local_memcache_create(rstring_ptr(namespace), 
       double_value(size_mb), &e);
-  if (!lmc) { raise_exception(&e); }
-  return Data_Wrap_Struct(klass, NULL, local_memcache_free, lmc);
+  if (!l)  rb_lmc_raise_exception(&e);
+  rb_lmc_handle_t *h = calloc(1, sizeof(rb_lmc_handle_t));
+  if (!h) rb_raise(rb_eRuntimeError, "memory allocation error");
+  h->lmc = l;
+  h->open = 1;
+  return Data_Wrap_Struct(klass, NULL, rb_lmc_free_handle, h);
 }
 
+/* :nodoc: */
+local_memcache_t *get_LocalMemCache(VALUE obj) {
+  rb_lmc_handle_t *h;
+  Data_Get_Struct(obj, rb_lmc_handle_t, h);
+  return rb_lmc_check_handle_access(h);
+}
+
+
 /* :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(&e); 
+    rb_lmc_raise_exception(&e); 
   }
   return Qnil;
 }
@@ -67,7 +115,7 @@ static VALUE LocalMemCache__clear_namespace(VALUE klass, VALUE ns,
 static VALUE LocalMemCache__check_namespace(VALUE klass, VALUE ns) {
   lmc_error_t e;
   if (!local_memcache_check_namespace(rstring_ptr(ns), &e)) {
-    raise_exception(&e); 
+    rb_lmc_raise_exception(&e); 
   }
   return Qnil;
 }
@@ -85,12 +133,6 @@ static VALUE LocalMemCache__disable_test_crash(VALUE klass) {
   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:
@@ -120,7 +162,7 @@ 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_length(key), 
       rstring_ptr(value), rstring_length(value))) { 
-    raise_exception(&lmc->error); 
+    rb_lmc_raise_exception(&lmc->error); 
   }
   return Qnil;
 }
@@ -145,7 +187,11 @@ static VALUE LocalMemCache__delete(VALUE obj, VALUE key) {
  */
 static VALUE LocalMemCache__close(VALUE obj) {
   lmc_error_t e;
-  if (!local_memcache_free(get_LocalMemCache(obj), &e)) raise_exception(&e);
+  rb_lmc_handle_t *h;
+  Data_Get_Struct(obj, rb_lmc_handle_t, h);
+  if (!local_memcache_free(rb_lmc_check_handle_access(h), &e)) 
+      rb_lmc_raise_exception(&e);
+  h->open = 0;
   return Qnil;
 }
 
@@ -153,12 +199,14 @@ typedef struct {
   VALUE ary;
 } lmc_ruby_iter_collect_keys;
 
+/* :nodoc: */
 int lmc_ruby_iter(void *ctx, const char* key, const char* value) {
   lmc_ruby_iter_collect_keys *data = ctx;
   rb_ary_push(data->ary, lmc_ruby_string(key));
   return 1;
 }
 
+/* :nodoc: */
 static VALUE __LocalMemCache__keys(VALUE d) {
   VALUE obj = rb_ary_entry(d, 0);
   VALUE r = rb_ary_entry(d, 1);

data/src/tests/extconf.rb

@@ -7,8 +7,12 @@ $defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
 $srcs = ['lmctestapi.c']
 $objs = ['lmctestapi.o']
 
-$CFLAGS << " -D_REENTRANT -g -I .."
-$LDFLAGS << " ../liblmc.a -lpthread -lrt"
+$CFLAGS << " -g -I .."
+$LDFLAGS << " -lpthread "
+$LOCAL_LIBS << "../liblmc.a"
+if have_library("rt")
+  $LDFLAGS << " -lrt"
+end
 
 dir_config('lmctestapi')
 create_makefile('lmctestapi')

data/src/tests/lmc.rb

@@ -6,11 +6,11 @@ require 'localmemcache'
 
 Bacon.summary_on_exit
 
-LocalMemCache.clear_namespace("testing", true)
-$lm = LocalMemCache.new :namespace=>"testing"
+LocalMemCache.clear_namespace("test", true)
+$lm = LocalMemCache.new :namespace=>"test"
 
-LocalMemCache.clear_namespace("testing-small", true)
-$lms = LocalMemCache.new :namespace=>"testing-small", :size_mb => 0.01;
+LocalMemCache.clear_namespace("test-small", true)
+$lms = LocalMemCache.new :namespace=>"test-small", :size_mb => 0.01;
 
 describe 'LocalMemCache' do
 
@@ -42,17 +42,22 @@ describe 'LocalMemCache' do
     $lm["null"].should.equal "foo\0goo"
   end
 
+  it 'should throw an exception when accessing a closed pool' do
+    $lm.close
+    should.raise(LocalMemCache::MemoryPoolClosed) { $lm.keys }
+  end
+
   it 'should throw exception if pool is full' do
     $lms["one"] = "a";
     should.raise(LocalMemCache::MemoryPoolFull) { $lms["two"] = "b" * 8000; }
   end
 
   it 'should support checking of namespaces' do 
-    LocalMemCache.check_namespace("testing")
+    LocalMemCache.check_namespace("test")
   end
 
   it 'should support clearing of namespaces' do
-    LocalMemCache.clear_namespace("testing")
+    LocalMemCache.clear_namespace("test")
   end
 
 

data/src/tests/lmctestapi.c

@@ -7,6 +7,14 @@
 #include "lmc_hashtable.h"
 #include "lmc_valloc.h"
 
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(x) RSTRING(x)->len
+#endif
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(x) RSTRING(x)->ptr
+#endif
+
 void *memp = NULL;
 static VALUE OutOfMemoryError;
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: localmemcache
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Sven C. Koehler
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-30 00:00:00 +00:00
+date: 2009-04-05 00:00:00 +00:00
 default_executable: 
 dependencies: []