localmemcache 0.3.0 → 0.4.0

data/site/doc/classes/LocalMemCache/ShmUnlockFailed.html

@@ -55,8 +55,8 @@
         <tr class="top-aligned-row">
             <td><strong>In:</strong></td>
             <td>
-                <a href="../../files/__/src/ruby-binding/localmemcache_rb.html">
-                ../src/ruby-binding/localmemcache.rb
+                <a href="../../files/localmemcache_rb.html">
+                localmemcache.rb
                 </a>
         <br />
             </td>

data/site/doc/created.rid

@@ -1 +1 @@
-Fri, 17 Apr 2009 00:10:05 +0000
+Wed, 06 May 2009 09:55:58 +0000

data/site/doc/fr_class_index.html

@@ -22,6 +22,7 @@
   <div id="index-entries">
     <a href="classes/LocalMemCache.html">LocalMemCache</a><br />
     <a href="classes/LocalMemCache/ArgError.html">LocalMemCache::ArgError</a><br />
+    <a href="classes/LocalMemCache/DBVersionNotSupported.html">LocalMemCache::DBVersionNotSupported</a><br />
     <a href="classes/LocalMemCache/InitError.html">LocalMemCache::InitError</a><br />
     <a href="classes/LocalMemCache/LocalMemCacheError.html">LocalMemCache::LocalMemCacheError</a><br />
     <a href="classes/LocalMemCache/LockError.html">LocalMemCache::LockError</a><br />
@@ -30,6 +31,7 @@
     <a href="classes/LocalMemCache/MemoryPoolFull.html">LocalMemCache::MemoryPoolFull</a><br />
     <a href="classes/LocalMemCache/OutOfMemoryError.html">LocalMemCache::OutOfMemoryError</a><br />
     <a href="classes/LocalMemCache/RecoveryFailed.html">LocalMemCache::RecoveryFailed</a><br />
+    <a href="classes/LocalMemCache/SharedObjectStorage.html">LocalMemCache::SharedObjectStorage</a><br />
     <a href="classes/LocalMemCache/ShmError.html">LocalMemCache::ShmError</a><br />
     <a href="classes/LocalMemCache/ShmLockFailed.html">LocalMemCache::ShmLockFailed</a><br />
     <a href="classes/LocalMemCache/ShmUnlockFailed.html">LocalMemCache::ShmUnlockFailed</a><br />

data/site/doc/fr_file_index.html

@@ -20,8 +20,9 @@
 <div id="index">
   <h1 class="section-bar">Files</h1>
   <div id="index-entries">
-    <a href="files/__/src/ruby-binding/localmemcache_rb.html">../src/ruby-binding/localmemcache.rb</a><br />
-    <a href="files/__/src/ruby-binding/rblocalmemcache_c.html">../src/ruby-binding/rblocalmemcache.c</a><br />
+    <a href="files/extconf_rb.html">extconf.rb</a><br />
+    <a href="files/localmemcache_rb.html">localmemcache.rb</a><br />
+    <a href="files/rblocalmemcache_c.html">rblocalmemcache.c</a><br />
   </div>
 </div>
 </body>

data/site/doc/fr_method_index.html

@@ -20,18 +20,24 @@
 <div id="index">
   <h1 class="section-bar">Methods</h1>
   <div id="index-entries">
-    <a href="classes/LocalMemCache.html#M000007">[] (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000010">[]= (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000005">check (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000003">check_namespace (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000004">clear (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000002">clear_namespace (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000012">close (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000008">delete (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000006">get (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000011">keys (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache/SharedObjectStorage.html#M000016">[] (LocalMemCache::SharedObjectStorage)</a><br />
+    <a href="classes/LocalMemCache.html#M000005">[] (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000009">[]= (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache/SharedObjectStorage.html#M000015">[]= (LocalMemCache::SharedObjectStorage)</a><br />
+    <a href="classes/LocalMemCache.html#M000003">check (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000008">clear (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000013">close (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000006">delete (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000002">drop (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000011">each_pair (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache/SharedObjectStorage.html#M000017">each_pair (LocalMemCache::SharedObjectStorage)</a><br />
+    <a href="classes/LocalMemCache.html#M000004">get (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000010">keys (LocalMemCache)</a><br />
     <a href="classes/LocalMemCache.html#M000001">new (LocalMemCache)</a><br />
-    <a href="classes/LocalMemCache.html#M000009">set (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000012">random_pair (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache/SharedObjectStorage.html#M000018">random_pair (LocalMemCache::SharedObjectStorage)</a><br />
+    <a href="classes/LocalMemCache.html#M000007">set (LocalMemCache)</a><br />
+    <a href="classes/LocalMemCache.html#M000014">size (LocalMemCache)</a><br />
   </div>
 </div>
 </body>

data/site/doc/index.html

@@ -19,6 +19,6 @@
         <frame src="fr_class_index.html"  name="Classes" />
         <frame src="fr_method_index.html" name="Methods" />
     </frameset>
-    <frame src="files/__/src/ruby-binding/localmemcache_rb.html" name="docwin" />
+    <frame src="files/localmemcache_rb.html" name="docwin" />
 </frameset>
 </html>

data/site/index.html

@@ -9,25 +9,28 @@
 <div id="content">
 <h1>A persistent key-value database based on mmap()'ed shared memory</h1>
 
-<p><b>Localmemcache</b> is a library for C and ruby that aims to provide
+<p><b>Localmemcache</b> is a library for <b>C</b> and <b>Ruby</b> 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.
-Since version 0.3.0 it supports persistence, also making it a fast
-alternative to GDBM and Berkeley DB.
+remote data.  It's based on <b>mmap()</b>'ed shared memory for <b>maximum
+speed</b>.
+Since version 0.3.0 it supports <b>persistence</b>, also making it <b>a fast
+alternative to GDBM and Berkeley DB</b>.
 
-<h2>Key features as of 0.3.0 (2009-04-17)</h2>
+<h2>Key features as of 0.4.0 (2009-05-16)</h2>
 <li><a href="#performance">blazingly fast</a></li>
+<li>a very simple API</li>
 <li>persistent</li>
 <li>parallel writes are supported by default</li>
 <li>uses transactions internally to avoid data corruption</li>
 <li>lightweight: the core library is just about <b>1400</b> lines of <b>C</b> code</li>
 
 <h2>Requirements</h2>
-<li>a &gt;=64bit Unix</li>
+<li>a &gt;=64bit Unix (32bit is possible but you'll run out of virtual address space quickly)</li>
 <li>a file system that offers <a href="http://en.wikipedia.org/wiki/Sparse_file">sparse files</a></li>
 Note for <b>OS X</b>: <b>OS X</b> disqualifies as <b>HFS+</b> doesn't
 have sparse files and <b>sem_timedwait</b>() and <b>sem_getvalue</b>() aren't
-supported as well.
+supported as well.<br>
 Note for <b>FreeBSD</b>: It has been reported that Localmemcache
 sometimes hangs there, it is not yet clear what the problem is.
 
@@ -42,15 +45,19 @@ sometimes hangs there, it is not yet clear what the problem is.
 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>
-<b>API</b>:&nbsp;<a href="http://github.com/sck/localmemcache/blob/e980ba949034a349dbf0e6f8f9ef77bbe3e3e314/src/localmemcache.h">C</a>|<a href="http://localmemcache.rubyforge.org/doc/">Ruby</a><br>
+<b>API</b>:&nbsp;<a href="http://github.com/sck/localmemcache/blob/591d943507236035e99471f372dc2826271610c9/src/localmemcache.h">C</a>|<a href="http://localmemcache.rubyforge.org/doc/">Ruby</a><br>
 <p><pre><code>require 'localmemcache'
 # 1. the memcached way
 # $lm = LocalMemCache.new :namespace => :viewcounters
 # 2. the GDBM way
-$lm = LocalMemCache.new :filename => "./viewcounters.lmc"
+#$lm = LocalMemCache.new :filename => "./viewcounters.lmc"
+# 3. Using LocalMemCache::SharedObjectStorage
+$lm = LocalMemCache::SharedObjectStorage.new :filename => 
+    "./viewcounters.lmc"
 $lm[:foo] = 1
 $lm[:foo]
 $lm.delete(:foo)
+
 </code></pre> 
 (C version of this example: <a href="http://github.com/sck/localmemcache/blob/e980ba949034a349dbf0e6f8f9ef77bbe3e3e314/example/hello.c">hello.c</a>)
 </p>
@@ -69,22 +76,20 @@ Ruby benchmark pseudo code:
 </code></pre>
 
 <pre>
-Tokyo Tyrant:          <b>298,226.197</b> ms
 MemCache:              <b>253,326.122</b> ms
 GDBM:                   <b>24,226.116</b> ms
-Localmemcache 0.2.2:     <b>5,799.225</b> ms
-Localmemcache 0.3.0:     <b>5,300.055</b> ms
+Tokyo Cabinet:           <b>9,092.707</b> ms
+Localmemcache 0.4.0:     <b>5,310.055</b> ms
 Ruby Hash of Strings:    <b>4,963.313</b> ms
 </pre>
-(<a href="http://github.com/sck/localmemcache/tree/e980ba949034a349dbf0e6f8f9ef77bbe3e3e314/bench">Code of the benchmarks used</a>)
+(<a href="http://github.com/sck/localmemcache/tree/7e5a9549a3b8c32662aaebaec3642253ce0ea8b0/bench">Code of the benchmarks used</a>)
 
 <p>
 
-So, on my machine, using <b>Localmemcache</b> 0.3.0 to store key-value
+So, on my machine, using <b>Localmemcache</b> 0.4.0 to store key-value
 data on disk is about <b>10</b>% slower than keeping them in memory in a
-Ruby hash of strings.   Also keep in mind that of the above mentioned
-software components <b>Tokyo Tyrant</b> is the only one that offers
-persistence and parallel writes like <b>Localmemcache</b> does.
+Ruby hash of strings.  It's about 70% faster than <b>Tokyo Cabinet</b>
+(which offers features similar to <b>LocalMemCache</b>).
 
 <h2>Source code</h2>
 
@@ -115,4 +120,15 @@ Localmemcache is freely distributable under the terms of an
 </div>
 
   </body>
+<script type="text/javascript">
+var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl."
+: "http://www.");
+document.write(unescape("%3Cscript src='" + gaJsHost +
+"google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
+</script>
+<script type="text/javascript">
+try {
+  var pageTracker = _gat._getTracker("UA-657352-3");
+  pageTracker._trackPageview();
+} catch(err) {}</script>
 </html>

data/src/lmc_common.c

@@ -51,7 +51,8 @@ void lmc_clean_string(char *result, const char *source) {
   for (; n--; d++, s++) {
     ch = *s;
     if ((ch >= 'a' && ch <= 'z') || 
-        (ch >= 'A' && ch <= 'Z')) {
+        (ch >= 'A' && ch <= 'Z') ||
+	(ch >= '0' && ch <= '9')) {
       *d = ch;
     } else {
       *d = '-';

data/src/lmc_common.h

@@ -5,7 +5,7 @@
 #ifndef _LMC_COMMON_H_INCLUDED_
 #define _LMC_COMMON_H_INCLUDED_
 
-#define LMC_DB_VERSION 0
+#define LMC_DB_VERSION 1
 
 extern int lmc_test_crash_enabled;
 #ifdef DO_TEST_CRASH

data/src/lmc_hashtable.c

@@ -131,6 +131,7 @@ 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;
+    ht->size += 1;
     lmc_log_finish(base);
   } else {
     LMC_TEST_CRASH
@@ -174,6 +175,7 @@ int ht_delete(void *base, va_ht_hash_t va_ht, const char *key, size_t n_key) {
     lmc_free(base, hr->va_key);
     lmc_free(base, hr->va_value);
     lmc_free(base, va_hr);
+    ht->size -= 1;
     return 1; 
 
   next:
@@ -183,21 +185,79 @@ int ht_delete(void *base, va_ht_hash_t va_ht, const char *key, size_t n_key) {
 }
 
 int ht_hash_iterate(void *base, va_ht_hash_t va_ht, void *ctx, 
-    LMC_ITERATOR_P(iter)) {
+    size_t *ofs, LMC_ITERATOR_P(iter)) {
   va_ht_hash_entry_t va_hr;
   ht_hash_entry_t *hr = &lmc_null_node;
   ht_hash_t *ht = base + va_ht;
   size_t k;
+  size_t item_c = 0;
+  size_t slice_counter = 0;
   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;
-      iter(ctx, base + hr->va_key, base + hr->va_value);
+      if (*ofs < ++item_c) {
+        iter(ctx, base + hr->va_key, base + hr->va_value);
+        if (++slice_counter > 999) {
+          *ofs = item_c;
+          return 2;
+        }
+      }
     }
   }
   return 1;
 }
 
+int ht_random_pair(void *base, va_ht_hash_t va_ht, char **r_key, 
+    size_t *n_key, char **r_value, size_t *n_value) {
+  va_ht_hash_entry_t va_hr;
+  ht_hash_t *ht = base + va_ht;
+  ht_hash_entry_t *hr = &lmc_null_node;
+  size_t k;
+  int rk = -1;
+  int filled_buckets = 0;
+  for (k = 0; k < LMC_HT_BUCKETS; k++) {
+    if (ht->va_buckets[k]) { filled_buckets++; }
+  }
+  if (filled_buckets == 0) { *r_key = 0x0;  r_value = 0x0; return 0; }
+  int bnr = rand() % filled_buckets;
+  for (k = 0; k < LMC_HT_BUCKETS; k++) {
+    if (ht->va_buckets[k] && bnr-- < 1) { 
+      rk = k; 
+      break;
+    }
+  }
+  if (rk == -1) {
+    printf("WHOA: Bucket not found!\n");
+    abort();
+  }
+  int pair_counter = 0;
+  hr = &lmc_null_node;
+  for (va_hr = ht->va_buckets[rk]; va_hr != 0 && hr != NULL; 
+       va_hr = hr->va_next) { 
+    hr = va_hr ? base + va_hr : 0;
+    pair_counter++; 
+  }
+  int random_pair = rand() % pair_counter;
+  hr = &lmc_null_node;
+  for (va_hr = ht->va_buckets[rk]; va_hr != 0 && hr != NULL; 
+      va_hr = hr->va_next) { 
+    hr = va_hr ? base + va_hr : 0;
+    if (random_pair-- < 1) { 
+      char *k = base + hr->va_key;
+      char *v = base + hr->va_value;
+      *r_key = lmc_string_data(k);
+      *n_key = lmc_string_len(k);
+      *r_value = lmc_string_data(v);
+      *n_value = lmc_string_len(v);
+      return 1;
+    }
+  }
+  printf("whoa no random entry found!\n");
+  abort();
+  return 0;
+}
+
 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;

data/src/lmc_hashtable.h

@@ -22,6 +22,7 @@ typedef struct {
 
 typedef size_t va_ht_hash_t;
 typedef struct {
+  size_t size;
   va_ht_hash_entry_t va_buckets[LMC_HT_BUCKETS];
 } ht_hash_t;
 
@@ -34,8 +35,10 @@ 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, 
+int ht_hash_iterate(void *base, va_ht_hash_t ht, void *ctx, size_t *ofs,
     LMC_ITERATOR_P(iter));
+int ht_random_pair(void *base, va_ht_hash_t va_ht, char **r_key, 
+    size_t *n_key, char **r_value, size_t *n_value);
 
 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_shm.c

@@ -73,15 +73,13 @@ void lmc_shm_ensure_namespace_file(const char *ns) {
   if (!lmc_does_namespace_exist(ns)) { close(open(fn, O_CREAT, 0777)); }
 }
 
-lmc_shm_t *lmc_shm_create(const char* namespace, size_t size, int use_persistence,
-    lmc_error_t *e) {
+lmc_shm_t *lmc_shm_create(const char* namespace, size_t size, lmc_error_t *e) {
   lmc_shm_t *mc = calloc(1, sizeof(lmc_shm_t));
   if (!mc) { 
     STD_OUT_OF_MEMORY_ERROR("lmc_shm_create");
     return NULL; 
   }
   snprintf((char *)&mc->namespace, 1023, "%s", namespace);
-  mc->use_persistence = 0;
   mc->size = size;
 
   lmc_shm_ensure_namespace_file(mc->namespace);

data/src/lmc_shm.h

@@ -10,12 +10,10 @@ typedef struct {
   int fd;
   void *base;
   size_t size;
-  int use_persistence;
   char namespace[1024];
 } lmc_shm_t;
 
-lmc_shm_t *lmc_shm_create(const char *namespace, size_t size, int use_persistence,
-    lmc_error_t *e);
+lmc_shm_t *lmc_shm_create(const char *namespace, size_t size, lmc_error_t *e);
 int lmc_shm_destroy(lmc_shm_t *mc, lmc_error_t *e);
 int lmc_does_namespace_exist(const char *ns);
 int lmc_namespace_size(const char *ns);

data/src/lmc_valloc.c

@@ -116,6 +116,11 @@ void lmc_init_memory(void *ptr, size_t size) {
   c->size = s;
 }
 
+size_t lmc_get_db_version(void *ptr) {
+  lmc_mem_descriptor_t *md = ptr;
+  return md->version;
+}
+
 size_t lmc_max(size_t a, size_t b) { 
   return a > b ? a : b;
 }

data/src/lmc_valloc.h

@@ -41,6 +41,7 @@ void lmc_free(void *base, size_t chunk);
 lmc_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);
+size_t lmc_get_db_version(void *ptr);
 
 int lmc_um_mark_allocated(void *base, char *bf, size_t va);
 char *lmc_um_new_mem_usage_bitmap(void *base);

data/src/localmemcache.c

@@ -55,13 +55,13 @@ int lmc_namespace_or_filename(char *result, const char* ons, const char *ofn,
   return 0;
 }
 
-int local_memcache_clear_namespace(const char *namespace, const char *filename,
-    int repair, lmc_error_t *e) {
+int local_memcache_drop_namespace(const char *namespace, const char *filename,
+    int force, lmc_error_t *e) {
   char clean_ns[1024];
   if (!lmc_namespace_or_filename((char *)clean_ns, namespace, filename, e))
       return 1;
   lmc_clean_namespace((char *)clean_ns, e);
-  if (repair) {
+  if (force) {
     lmc_lock_t *l = lmc_lock_init((char *)clean_ns, 1, e);
     lmc_lock_repair(l);
     free(l);
@@ -106,7 +106,7 @@ retry:
   {
     if (*ok && !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) 
+    if ((lmc->shm = lmc_shm_create(lmc->namespace, lmc->size, e)) == NULL) 
         goto release_and_fail;
     lmc->base = lmc->shm->base;
     if (!*ok || is_lmc_already_initialized(lmc->base)) {
@@ -114,6 +114,11 @@ retry:
         if (!force)  goto release_and_fail;
         *ok = 0;
       }
+      if (lmc_get_db_version(lmc->base) != LMC_DB_VERSION) {
+        lmc_handle_error_with_err_string("local_memcache_create",
+            "DB version is incompatible", "DBVersionNotSupported", e);
+        goto unlock_and_fail;
+      }
       lmc_mem_descriptor_t *md = lmc->base;
       lmc->va_hash = md->va_hash;
     } else {
@@ -230,8 +235,6 @@ int local_memcache_check_namespace(const char *namespace, const char *filename,
   return __local_memcache_check_namespace(clean_ns, e);
 }
 
-
-
 int lmc_lock_shm_region(const char *who, local_memcache_t *lmc) {
   int r;
   int retry_counter = 0;
@@ -279,6 +282,27 @@ char *local_memcache_get_new(local_memcache_t *lmc,
   return new_s;
 }
 
+int __local_memcache_random_pair(local_memcache_t *lmc, 
+    char **r_key, size_t *n_key, char **r_value, size_t *n_value) {
+  if (!lmc_lock_shm_region("local_memcache_random_pair", lmc)) return 0;
+  return ht_random_pair(lmc->base, lmc->va_hash, r_key, n_key, r_value, 
+      n_value);
+}
+
+int local_memcache_random_pair_new(local_memcache_t *lmc, 
+    char **r_key, size_t *n_key, char **r_value, size_t *n_value) {
+  char *k;
+  char *v;
+  if (__local_memcache_random_pair(lmc, &k, n_key, &v, n_value)) {
+    char *new_k = malloc(*n_key);
+    memcpy(new_k, k, *n_key);
+    char *new_v = malloc(*n_value);
+    memcpy(new_v, v, *n_value);
+  }
+  if (!lmc_unlock_shm_region("local_memcache_random_pair", lmc)) return 0;
+  return 1;
+}
+
 int local_memcache_set(local_memcache_t *lmc, 
    const char *key, size_t n_key, const char* value, size_t n_value) {
   if (!lmc_lock_shm_region("local_memcache_set", lmc)) return 0;
@@ -288,6 +312,17 @@ int local_memcache_set(local_memcache_t *lmc,
   return r;
 }
 
+int local_memcache_clear(local_memcache_t *lmc) {
+  if (!lmc_lock_shm_region("local_memcache_clear", lmc)) return 0;
+  lmc_init_memory(lmc->base, lmc->size);
+  lmc_mem_descriptor_t *md = lmc->base;
+  int r = 1;
+  if ((md->va_hash = ht_hash_create(lmc->base, &lmc->error)) == 0) { r = 0; }
+  else { lmc->va_hash = md->va_hash; }
+  if (!lmc_unlock_shm_region("local_memcache_clear", lmc)) return 0;
+  return r;
+}
+
 int local_memcache_delete(local_memcache_t *lmc, char *key, size_t n_key) {
   if (!lmc_lock_shm_region("local_memcache_delete", lmc)) return 0;
   int r = ht_delete(lmc->base, lmc->va_hash, key, n_key);
@@ -306,9 +341,9 @@ int local_memcache_free(local_memcache_t *lmc, lmc_error_t *e) {
 }
 
 int local_memcache_iterate(local_memcache_t *lmc, void *ctx, 
-    LMC_ITERATOR_P(iter)) {
+    size_t *ofs, 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);
+  int r = ht_hash_iterate(lmc->base, lmc->va_hash, ctx, ofs, iter);
   if (!lmc_unlock_shm_region("local_memcache_iterate", lmc)) return 0;
   return r;
 }