localmemcache 0.0.1 → 0.2.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.o
+*.a
+core
+vgcore*
+core*
+*.bak
+.*.sw?
+autom4te.cache
+config.status
+*.bin
+?
+config.log
+lmc_config.h
+Makefile
+*.so
+pkg
+

data/INTERNALS

@@ -0,0 +1,26 @@
+How localmemcache works
+=======================
+
+localmemcache is essentially three components:
+
+- a wrapper around mmap()
+- an allocator that works with relative memory addresses (replaces malloc(), etc.)
+- hashtable data type
+
+Namespace life-cycle
+====================
+
+| $lm = LocalMemCache.new :namespace => :viewcounters #, :size_mb => 1024
+
+Namespaces reside as memory-mapped files in /var/tmp/localmemcache.  If the
+namespace does not yet exist, it is created with a default size of 1GB.  It is
+not possible to resize a namespace, so choose a size that will be enough to
+hold all your data.  The class method clear_namespace can be used to delete
+namespaces.  You should also use this function in case your namespace becomes
+inconsistent.  Note that just deleting the memory-mapped file is not enough.
+
+The default size of a namespace is 1GB, it can be changed by passing the option
+:size_mb to the constructor.  Note that this is the maximum size of the shared
+memory segment which cannot be extended later without clearing the namespace
+first.  Setting large sizes shouldn't be much of a problem since only that
+memory which is really used will exist in physical ram and disk.

data/README

@@ -1,34 +1,24 @@
-localmemcache README
+Localmemcache README
 =====================
 
-Efficiently sharing a hashtable between processes on a local Unix machine.
-
-WHAT IS IT?
-===========
-
-localmemcache aims to be faster than using memcached locally by using shared
-memory, but providing a similar interface.
+The beauty of memcached.  For local data.  Blazingly fast.
 
+* http://localmemcache.rubyforge.org/
 
-PERFORMANCE
+WHAT IS IT?
 ===========
-Here's a quick speed comparison, made on an 
-Intel(R) Xeon(R) CPU E5205 @ 1.86GHz:
-
-Benchmark pseudo code:
 
-2_000_000.times {
-  index = rand(10000).to_s
-  $hash.set(index, index)
-  $hash.get(index)
-}
+Localmemcache 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 mmap()'ed shared memory for maximum speed.
 
-MemCache:      253326.122 ms
-LocalMemCache: 6055.552 ms
-Ruby's Hash:   4963.313 ms
+SUPPORTED SYSTEMS
+=================
 
-So localmemcache is about 40 times faster than using memcache locally, and
-about 20% slower than Ruby's hash.
+- Unix (for mmap)
+- 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.
 
 EXAMPLE
 =======
@@ -36,48 +26,18 @@ EXAMPLE
 In Ruby:
 
 require 'localmemcache'
-$lm = LocalMemCache.new :namespace => :viewcounters
+$lm = LocalMemCache.new :namespace => "viewcounters"
 $lm[:foo] = 1
 $lm[:foo]
 $lm.delete(:foo)
 
-
 INSTALLATION
 ============
 
-# gem install localmemcache
+Ruby binding:
 
-How localmemcache works
-=======================
-
-localmemcache is essentially three components:
-
-- a wrapper around mmap()
-- an allocator that works with relative memory addresses (replaces malloc(), etc.)
-- hashtable data type
-
-Namespace life-cycle
-====================
-
-| $lm = LocalMemCache.new :namespace => :viewcounters #, :size_mb => 1024
-
-Namespaces reside as memory-mapped files in /var/tmp/localmemcache.  If the
-namespace does not yet exist, it is created with a default size of 1GB.  It is
-not possible to resize a namespace, so choose a size that will be enough to
-hold all your data.  The class method clear_namespace can be used to delete
-namespaces.  You should also use this function in case your namespace becomes
-inconsistent.  Note that just deleting the memory-mapped file is not enough.
-
-The default size of a namespace is 1GB, it can be changed by passing the option
-:size_mb to the constructor.  Note that this is the maximum size of the shared
-memory segment which cannot be extended later without clearing the namespace
-first.  Setting large sizes shouldn't be much of a problem since only that
-memory which is really used will exist in physical ram and disk.
+# gem install localmemcache
 
-SUPPORTED SYSTEMS
-=================
+If you just want to use the C API, download the .tar.gz from:
 
-- Unix (for mmap)
-- A CPU architecture with more than 32 bit is recommended, since otherwise you
-  might run out of virtual address space when you use larger shared memory
-  segments.
+http://rubyforge.org/frs/?group_id=7925

data/Rakefile

@@ -5,13 +5,13 @@ def manifest
   `git ls-files`.split("\n").select{|n| !%r!/site/!.match(n) }
 end
 
-def version() File.read("VERSION") end
+def version() File.read("VERSION").chomp end
 
 desc "Generate a ChangeLog"
 task :changelog do
   File.open("ChangeLog", "w") { |out|
     `git log -z`.split("\0").map { |chunk|
-      author = chunk[/Author: (.*)/, 1].strip
+      author = chunk[/Author: (.*)/, 1].strip.gsub(/mysites/, "Sven C. Koehler")
       date = chunk[/Date: (.*)/, 1].strip
       desc, detail = $'.strip.split("\n", 2)
       detail ||= ""
@@ -24,6 +24,13 @@ task :changelog do
   }
 end
 
+task :c_api_package do
+  tgz = "pkg/localmemcache-#{version}.tar.gz"
+  sh "test -d pkg || mkdir pkg"
+  puts "Creating #{tgz}"
+  sh "tar czf #{tgz.inspect} #{manifest.map{|n| n.inspect }.join(" ")}"
+end
+
 #task :pushsite => [:rdoc] do
 task :pushsite do
   sh "chmod 755 site"
@@ -47,8 +54,8 @@ else
     s.name            = "localmemcache"
     s.version         = version
     s.platform        = Gem::Platform::RUBY
-    s.summary         = "Efficiently sharing a hashtable between " +
-        "processes on a local Unix machine."
+    s.summary         = "The beauty of memcached.  For local data.  " + 
+        "Blazingly fast" 
 
     s.description = <<-EOF
 

data/THANKS

@@ -0,0 +1 @@
+Armin Roehrl: For his thoughts and support

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.2.0

data/example/compile.sh

@@ -0,0 +1,3 @@
+#! /bin/sh
+
+gcc -o hello.bin hello.c -I ../src/ -L ../src -llmc -lrt

data/example/hello

@@ -0,0 +1,10 @@
+#! /bin/sh
+D=`dirname $0`
+DIR=`cd $D; pwd`
+script=$DIR/hello.rb
+
+if test "x$1" = "x-d"; then
+  irb -r $script
+else
+  ruby $script
+fi

data/example/hello.c

@@ -0,0 +1,28 @@
+#include <stdio.h>
+#include <localmemcache.h>
+
+int main() {
+  lmc_error_t e;
+  local_memcache_t *lmc = local_memcache_create("viewcounters", 0, &e);
+  if (!lmc) {
+    fprintf(stderr, "Couldn't create localmemcache: %s\n", e.error_str);
+    return 1;
+  }
+  if (!local_memcache_set(lmc, "foo", 3, "1", 1)) goto failed;
+  size_t n_value;
+  char *value = local_memcache_get_new(lmc, "foo", 3, &n_value);
+  if (!value) goto failed;
+  free(value);
+  if (!local_memcache_delete(lmc, "foo", 3)) goto failed;
+  if (!local_memcache_free(lmc, &e)) {
+    fprintf(stderr, "Failed to release localmemcache: %s\n", e.error_str);
+    return 1;
+  }
+
+  return 0;
+
+failed:
+  fprintf(stderr, "%s\n", lmc->error.error_str);
+  return 1;
+
+}

data/example/hello.rb

@@ -0,0 +1,8 @@
+$DIR=File.dirname(__FILE__)
+['../src/ruby-binding/'].each {|p| $:.unshift File.join($DIR, p) }
+
+require 'localmemcache'
+$lm = LocalMemCache.new :namespace => "viewcounters"
+$lm[:foo] = 1
+$lm[:foo]
+$lm.delete(:foo)

data/src/Makefile.in

@@ -1,7 +1,7 @@
 CC=@CC@
 VERSION=@VERSION@
 TARGET=liblmc.a
-CFLAGS=-Wall -Wunused  -fPIC -O2
+CFLAGS_ADD=-g -Wall -Wunused  -fPIC -O2
 RUBY_LIB=rblocalmemcache.so
 LDFLAGS=
 AR=ar
@@ -14,6 +14,7 @@ OFILES= \
 	lmc_hashtable.o \
 	lmc_shm.o \
 	lmc_lock.o \
+	lmc_common.o \
 	localmemcache.o 
 
 compile: $(TARGET) 
@@ -31,7 +32,7 @@ $(TARGET): $(OFILES)
 	$(RANLIB) $@
 
 %.o: %.c
-	$(CC) $(CFLAGS) -c -o $@ $<
+	$(CC) $(CFLAGS_ADD) $(CFLAGS) -c -o $@ $<
 
 test: $(TARGET)
 	./tests/runtest.sh
@@ -42,8 +43,8 @@ install: $(TARGET)
 	install -d -m755 ${PREFIX}/include
 	install -m644 ${TARGET} ${PREFIX}/lib
 	@echo INSTALLING headers to ${PREFIX}/include
-	install -m644 lmc_config.h lmc_error.h lmc_hashtable.h lmc_lock.h \
-	lmc_shm.h lmc_valloc.h ${PREFIX}/include 
+	install -m644 lmc_config.h lmc_common.h lmc_error.h lmc_hashtable.h \
+	lmc_lock.h lmc_shm.h lmc_valloc.h ${PREFIX}/include 
 
 clean: 
 	rm -f *.log *.so *.a *.o tests/core tests/vgcore* \

data/src/lmc_common.c

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2009, Sven C. Koehler
+ */
+
+#include "localmemcache.h"
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+
+int lmc_test_crash_enabled = 0;
+int lmc_showed_status = 0;
+
+void lmc_test_crash(const char* file, int line, const char *function) {
+  if (!lmc_showed_status) {
+    lmc_showed_status = 1;
+    printf("lmc_test_crash enabled\n");
+  }
+  if (!lmc_test_crash_enabled) { return; }
+  int r = rand();
+  if ((r & 63) == 0) {
+    printf("[%s:%d %s %d] CRASHING: %d\n", file, line, function, getpid(), r);
+    char *p = 0x0;
+    *p = 0x0;
+  }
+}
+
+#undef lmc_valloc
+
+size_t lmc_test_valloc_fail(const char *file, int line, const char *function,
+    void *base, size_t s) {
+  if (!lmc_showed_status) {
+    lmc_showed_status = 1;
+    printf("lmc_test_valloc enabled\n");
+  }
+  int r = rand();
+  if ((r & 255) == 0) {
+    printf("[%s:%d %s] valloc fail: %zd\n", file, line, function, s);
+    return 0;
+  }
+  return lmc_valloc(base, s);
+}
+

data/src/lmc_common.h

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2009, Sven C. Koehler
+ */
+
+#ifndef _LMC_COMMON_H_INCLUDED_
+#define _LMC_COMMON_H_INCLUDED_
+
+extern int lmc_test_crash_enabled;
+#ifdef DO_TEST_CRASH
+#define LMC_TEST_CRASH lmc_test_crash(__FILE__, __LINE__, __FUNCTION__);
+#else
+#define LMC_TEST_CRASH
+#endif
+
+#ifdef DO_TEST_ALLOC_FAILURE
+#define lmc_valloc(base, s) \
+    lmc_test_valloc_fail(__FILE__, __LINE__, __FUNCTION__, base, s)
+#endif
+
+
+void lmc_test_crash(const char* file, int line, const char *function);
+size_t lmc_test_valloc_fail(const char *file, int line, const char *function,
+    void *base, size_t s);
+
+#endif
+

data/src/lmc_error.c

@@ -1,18 +1,24 @@
+/*
+ * Copyright (c) 2009, Sven C. Koehler
+ */
+
 #include "lmc_error.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <string.h>
 
-int lmc_handle_error(int check, const char *ctx, lmc_error_t *e) {
+int lmc_handle_error(int check, const char *ctx, const char *error_type, 
+    lmc_error_t *e) {
   if (!check) { return LMC_OK; } 
-  return lmc_handle_error_with_err_string(ctx, strerror(errno), e);
+  return lmc_handle_error_with_err_string(ctx, strerror(errno), error_type, e);
 }
 
 int lmc_handle_error_with_err_string(const char *ctx, 
-    const char *error_msg, lmc_error_t *e) {
+    const char *error_msg, const char* error_type, lmc_error_t *e) {
   if (!e) { return LMC_OK; } 
   snprintf((char *)&e->error_str, 1023, "%s: %s", ctx, error_msg);
+  snprintf((char *)&e->error_type, 1023, "%s", error_type);
   e->error_number = errno;
   return LMC_ERROR;
 }

data/src/lmc_error.h

@@ -10,10 +10,20 @@
 
 typedef struct {
   char error_str[1024];
+  char error_type[1024];
   int error_number;
 } lmc_error_t;
 
-int lmc_handle_error(int check, const char *ctx, lmc_error_t* e);
-int lmc_handle_error_with_err_string(const char *ctx, const char* error_msg,
+#define STD_OUT_OF_MEMORY_ERROR(ctx) \
+    lmc_handle_error_with_err_string((ctx), "Out of memory error", \
+        "OutOfMemoryError", e)
+
+#define LMC_MEMORY_POOL_FULL(ctx) \
+    lmc_handle_error_with_err_string((ctx), "Memory pool full", \
+        "MemoryPoolFull", e)
+
+int lmc_handle_error(int check, const char *ctx, const char *error_type, 
     lmc_error_t* e);
+int lmc_handle_error_with_err_string(const char *ctx, const char *error_msg,
+    const char *error_type, lmc_error_t* e);
 #endif

data/src/lmc_hashtable.c

@@ -7,19 +7,30 @@
 #include <string.h>
 
 #include "lmc_hashtable.h"
-#include "lmc_valloc.h"
+#include "lmc_common.h"
 
-size_t ht_strdup(void *base, const char *s) {
-  size_t va_s = lmc_valloc(base, strlen(s) + 1);
+#define LMC_OP_HT_SET 1
+
+typedef struct {
+   int op_id;
+   size_t va_key;
+   size_t va_value;
+} lmc_log_ht_set;
+
+size_t lmc_ht_strdup(void *base, const char *s, size_t l) {
+  size_t va_s = lmc_valloc(base, l +  sizeof(size_t) + 1);
   if (!va_s) { return 0; }
-  //memcpy(base + va_s, s, strlen(s) + 1);
-  strcpy(base + va_s, s);
+  char *p = base + va_s;
+  *(size_t *) p = l;
+  p += sizeof(size_t);
+  memcpy(p, s, l + 1);
   return va_s;
 }
 
-unsigned long ht_hash_key(const char *s) {
+unsigned long ht_hash_key(const char *s, size_t l) {
   unsigned long v;
-  for (v = 0; *s != '\0'; s++) { v = *s + 31 * v; }
+  size_t i;
+  for (v = 0, i = 0; i++ < l; s++) { v = *s + 31 * v; }
   return v % HT_BUCKETS;
 }
 
@@ -28,7 +39,7 @@ ht_hash_entry_t 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));
   if (!va_ht) {
-    lmc_handle_error_with_err_string("ht_hash_create", "memory pool full", e);
+    LMC_MEMORY_POOL_FULL("ht_hash_create");
     return 0;
   }
   memset(base + va_ht, 0, sizeof(ht_hash_t));
@@ -40,65 +51,182 @@ int ht_hash_destroy(void *base, va_ht_hash_t ht) {
   return 1;
 }
 
-ht_hash_entry_t *ht_lookup(void *base, va_ht_hash_t va_ht, const char *key) {
+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_t *ht = base + va_ht;
-  for (va_hr = ht->va_buckets[ht_hash_key(key)]; 
-      va_hr != 0 && hr != NULL; va_hr = hr->va_next) {
+  size_t i;
+  for (va_hr = ht->va_buckets[ht_hash_key(key, n_key)]; 
+      va_hr != 0 && hr != NULL; ) {
     hr = va_hr ? base + va_hr : 0;
-    if (hr && (strcmp(key, base + hr->va_key) == 0)) { return hr; }
+    if (!hr) goto next;
+    char *s = base + hr->va_key;
+    size_t l = *(size_t *) s;
+    if (l != n_key) goto next;
+    s += sizeof(size_t);
+    for (i = 0; i < l; i++) {
+      if (s[i] != key[i]) goto next;
+    }
+    return hr;
+
+next:
+    va_hr = hr->va_next;
   }
   return &null_node;
 }
 
-char *ht_get(void *base, va_ht_hash_t va_ht, const char *key) { 
-  size_t va = ht_lookup(base, va_ht, key)->va_value; 
+ht_hash_entry_t *ht_lookup2(void *base, va_ht_hash_t va_ht, char *k) {
+  return ht_lookup(base, va_ht, k + sizeof(size_t), *(size_t *) k);
+}
+
+const char *ht_get(void *base, va_ht_hash_t va_ht, const char *key, 
+    size_t n_key, size_t *n_value) { 
+  size_t va = ht_lookup(base, va_ht, key, n_key)->va_value; 
   char *r = va ? base + va : 0;
-  return r;
+  if (!r) return 0;
+  *n_value = *(size_t *) r;
+  return r + sizeof(size_t);
+}
+
+size_t lmc_string_len(char *s) { return *(size_t *) s; }
+char *lmc_string_data(char *s) { return s + sizeof(size_t); }
+
+int ht_redo(void *base, va_ht_hash_t va_ht, lmc_log_descriptor_t *l, 
+    lmc_error_t *e) {
+  if (l->op_id == LMC_OP_HT_SET) {
+    lmc_log_ht_set *l_set = (lmc_log_ht_set *)l;
+    if (l_set->va_key == 0 || l_set->va_value == 0) { return 1; }
+    char *k = base + l_set->va_key;
+    char *v = base + l_set->va_value;
+    ht_set(base, va_ht, lmc_string_data(k), lmc_string_len(k),
+        lmc_string_data(v), lmc_string_len(v), e);
+    return 1;
+  }
+  return 0;
 }
 
 int ht_set(void *base, va_ht_hash_t va_ht, const char *key, 
-    const char *value, lmc_error_t *e) {
+    size_t n_key, const char *value, size_t n_value, lmc_error_t *e) {
   ht_hash_t *ht = base + va_ht;
-  ht_hash_entry_t *hr = ht_lookup(base, va_ht, 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 || (hr->va_key = ht_strdup(base, key)) == 0) { 
-      lmc_handle_error_with_err_string("ht_set", "memory pool full", e);
-      return 0; 
+    if (hr == NULL) { 
+      LMC_MEMORY_POOL_FULL("ht_set");
+      goto failed;
     }
-    v = ht_hash_key(key);
+    LMC_TEST_CRASH
+    hr->va_key = l->va_key;
+    v = ht_hash_key(key, n_key);
+    LMC_TEST_CRASH
     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_free(base, hr->va_value);
-  }
-  if ((hr->va_value = ht_strdup(base, value)) == 0) { 
-    lmc_handle_error_with_err_string("ht_set", "memory pool full", e);
-    return 0; 
+    LMC_TEST_CRASH
+    size_t va = hr->va_value;
+    if ((hr->va_value = lmc_ht_strdup(base, value, n_value)) == 0) {
+      LMC_MEMORY_POOL_FULL("ht_set");
+      goto failed_no_log;
+    }
+    lmc_free(base, va);
   }
   return 1;
+
+failed:
+  lmc_log_finish(base);
+failed_no_log:
+  return 0;
 }
 
-int ht_delete(void *base, va_ht_hash_t va_ht, const char *key) {
+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 *p = NULL;
+  size_t va_p = 0;
   ht_hash_t *ht = base + va_ht;
-  unsigned long k = ht_hash_key(key);
+  size_t i;
+  unsigned long k = ht_hash_key(key, n_key);
   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 && (strcmp(key, base + hr->va_key) == 0)) { 
-      // remove previous entry
-      if (p) { p->va_next = hr->va_next; }
-      else { ht->va_buckets[k] = 0; }
-      return 1; 
+    if (!hr) goto next;
+    char *s = base + hr->va_key;
+    size_t l = *(size_t *) s;
+    if (l != n_key) goto next;
+    s += sizeof(size_t);
+    for (i = 0; i < l; i++) {
+      if (s[i] != key[i]) goto next;
+    }
+
+    ht_hash_entry_t *p = va_p ? base + va_p : 0;
+    if (p) { p->va_next = hr->va_next; }
+    else { ht->va_buckets[k] = 0; }
+    lmc_free(base, hr->va_key);
+    lmc_free(base, hr->va_value);
+    lmc_free(base, va_hr);
+    return 1; 
+
+  next:
+    va_p = va_hr;
+  }
+  return 0;
+}
+
+int ht_hash_iterate(void *base, va_ht_hash_t va_ht, void *ctx, ITERATOR_P(iter)) {
+  va_ht_hash_entry_t va_hr;
+  ht_hash_entry_t *hr;
+  ht_hash_t *ht = base + va_ht;
+  size_t k;
+  for (k = 0; k < 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);
     }
-    p = base + hr->va_key;
   }
+  return 1;
+}
+
+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_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 (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 (!(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;
+    }
+  }
+  lmc_um_find_leaks(base, bf);
+  free(bf);
+  return 1;
+failed:
+  free(bf);
   return 0;
 }