localmemcache 0.0.1 → 0.2.0

data/src/lmc_hashtable.h

@@ -5,6 +5,7 @@
 #ifndef _LMC_HASHTABLE_H_INCLUDED_
 #define _LMC_HASHTABLE_H_INCLUDED_
 #include "lmc_error.h"
+#include "lmc_valloc.h"
 
 typedef size_t va_string_t;
 typedef size_t va_ht_hash_entry_t;
@@ -16,18 +17,25 @@ typedef struct {
 } ht_hash_entry_t;
 
 #define HT_BUCKETS 499
+#define 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];
 } ht_hash_t;
 
-
 va_ht_hash_t ht_hash_create(void *base, lmc_error_t *e);
-int ht_set(void *base, va_ht_hash_t va_ht, const char *key, const char *value,
-    lmc_error_t* e);
-ht_hash_entry_t *ht_lookup(void *base, va_ht_hash_t va_ht, const char *key);
-char *ht_get(void *base, va_ht_hash_t ht, const char *key);
-int ht_delete(void *base, va_ht_hash_t va_ht, const char *key);
+int ht_set(void *base, va_ht_hash_t va_ht, const char *key, 
+    size_t n_key, const char *value, size_t n_value, lmc_error_t *e);
+ht_hash_entry_t *ht_lookup(void *base, va_ht_hash_t va_ht, const char *key, 
+    size_t n_key);
+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_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, 
+    lmc_error_t *e);
 #endif

data/src/lmc_lock.c

@@ -4,27 +4,41 @@
 #include <sys/stat.h>
 #include <errno.h>
 #include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
 #include <time.h>
 #include "lmc_lock.h"
 
 int c_l(lmc_lock_t *l, lmc_error_t *e) { 
-  if (!l) { strncpy(e->error_str, "Semaphore not initialized", 1023); }
+  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", e);
+      "sem_open", "LockError", e);
   if (!l->sem) { free(l); return NULL; }
   return l;
 }
 
+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) {
@@ -35,12 +49,27 @@ int lmc_is_locked(lmc_lock_t* l, lmc_error_t *e) {
   }
 }
 
-int lmc_is_lock_working(lmc_lock_t* l, lmc_error_t *e) {
-  if (!c_l(l, e)) { return 0; }
+int lmc_sem_timed_wait(lmc_lock_t* l) {
   struct timespec ts;
   clock_gettime(CLOCK_REALTIME, &ts);
+#ifdef DO_TEST_CRASH
+  ts.tv_sec += 1;
+#else
   ts.tv_sec += 2;
-  if (sem_timedwait(l->sem, &ts) == -1) {
+#endif
+  return sem_timedwait(l->sem, &ts);
+}
+
+int lmc_sem_timed_wait_mandatory(lmc_lock_t* l) {
+  struct timespec ts;
+  clock_gettime(CLOCK_REALTIME, &ts);
+  ts.tv_sec += 20;
+  return sem_timedwait(l->sem, &ts);
+}
+
+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 {
     sem_post(l->sem);
@@ -51,15 +80,44 @@ int lmc_is_lock_working(lmc_lock_t* l, lmc_error_t *e) {
 void lmc_lock_repair(lmc_lock_t *l) {
   int v; 
   sem_getvalue(l->sem, &v);
-  if (v == 0) { sem_post(l->sem); }
+  if (v == 0) { 
+    sem_post(l->sem); 
+  }
+  sem_getvalue(l->sem, &v);
+  while (v > 1) { 
+    sem_wait(l->sem); 
+    sem_getvalue(l->sem, &v);
+  }
+}
+
+int lmc_lock_get_value(lmc_lock_t* l) {
+  int v = 0;
   sem_getvalue(l->sem, &v);
-  printf("value after repair: %d\n", v);
+  return v;
 }
 
 int lmc_lock_obtain(const char *where, lmc_lock_t* l, lmc_error_t *e) {
-  return c_l(l,e) && lmc_handle_error(sem_wait(l->sem) == -1, "sem_wait", e);
+  if (!c_l(l,e)) { return 0; }
+  int r = lmc_sem_timed_wait(l);
+  if (r == -1 && errno == ETIMEDOUT) {
+    lmc_handle_error_with_err_string("sem_timedwait", strerror(errno), 
+        "LockTimedOut", e);
+    return 0;
+  }
+  return lmc_handle_error(r, "sem_timedwait", "LockError", e);
+}
+
+int lmc_lock_obtain_mandatory(const char *where, lmc_lock_t* l, lmc_error_t *e) {
+  int r = lmc_sem_timed_wait_mandatory(l);
+  if (r == -1 && errno == ETIMEDOUT) {
+    lmc_handle_error_with_err_string("sem_timedwait", strerror(errno), 
+        "LockTimedOut", e);
+    return 0;
+  }
+  return c_l(l,e) && 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", e);
+  return c_l(l, e) && lmc_handle_error(sem_post(l->sem) == -1, "sem_post", 
+      "LockError", e);
 }

data/src/lmc_lock.h

@@ -14,9 +14,12 @@ typedef struct {
 
 lmc_lock_t *lmc_lock_init(const char *namespace, int init, lmc_error_t *e);
 int lmc_lock_obtain(const char *where, lmc_lock_t* l, lmc_error_t *e);
+int lmc_lock_obtain_mandatory(const char *where, lmc_lock_t* l, lmc_error_t *e);
 int lmc_lock_release(const char *where, lmc_lock_t* l, lmc_error_t *e);
 
 int lmc_is_locked(lmc_lock_t* l, lmc_error_t *e);
 int lmc_is_lock_working(lmc_lock_t* l, lmc_error_t *e);
 void lmc_lock_repair(lmc_lock_t *l);
+int lmc_lock_get_value(lmc_lock_t* l);
+int lmc_clear_namespace_lock(const char *namespace);
 #endif

data/src/lmc_shm.c

@@ -20,6 +20,12 @@ int lmc_does_file_exist(const char *fn) {
   return stat(fn, &st) != -1;
 }
 
+int lmc_file_size(const char *fn) {
+  struct stat st;
+  if (stat(fn, &st) == -1) return 0;
+  return st.st_size;
+}
+
 void lmc_shm_ensure_root_path() {
   if (!lmc_does_file_exist(LMC_SHM_ROOT_PATH)) {
     mkdir(LMC_SHM_ROOT_PATH, 01777);
@@ -36,12 +42,20 @@ int lmc_does_namespace_exist(const char *ns) {
   return lmc_does_file_exist(fn);
 }
 
+int lmc_namespace_size(const char *ns) {
+  char fn[1024];
+  lmc_file_path_for_namespace((char *)&fn, ns);
+  if (!lmc_does_file_exist(fn)) { return 0; }
+  return lmc_file_size(fn);
+}
+
 int lmc_clean_namespace(const char *ns, lmc_error_t *e) {
   lmc_shm_ensure_root_path();
   char fn[1024];
   lmc_file_path_for_namespace((char *)&fn, ns);
   if (lmc_does_namespace_exist(ns)) {
-    if (!lmc_handle_error(unlink(fn) == -1,  "unlink", e)) { return 0; }
+    if (!lmc_handle_error(unlink(fn) == -1,  "unlink", "ShmError", 
+        e)) { return 0; }
   }
   return 1;
 }
@@ -57,7 +71,7 @@ lmc_shm_t *lmc_shm_create(const char* namespace, size_t size, int use_persistenc
     lmc_error_t *e) {
   lmc_shm_t *mc = calloc(1, sizeof(lmc_shm_t));
   if (!mc) { 
-    lmc_handle_error_with_err_string("lmc_shm_create", "Out of memory", e);
+    STD_OUT_OF_MEMORY_ERROR("lmc_shm_create");
     return NULL; 
   }
   strncpy((char *)&mc->namespace, namespace, 1023);
@@ -68,13 +82,15 @@ lmc_shm_t *lmc_shm_create(const char* namespace, size_t size, int use_persistenc
   char fn[1024];
   lmc_file_path_for_namespace((char *)&fn, mc->namespace);
   if (!lmc_handle_error((mc->fd = open(fn, O_RDWR, (mode_t)0777)) == -1, 
-      "open", e)) goto open_failed;
-  if (!lmc_handle_error(lseek(mc->fd, mc->size - 1, SEEK_SET) == -1, "lseek", e)) 
-      goto failed;
-  if (!lmc_handle_error(write(mc->fd, "", 1) != 1, "write", e)) goto failed;
+      "open", "ShmError", e)) goto open_failed;
+  if (!lmc_handle_error(lseek(mc->fd, mc->size - 1, SEEK_SET) == -1, 
+      "lseek", "ShmError", e)) goto failed;
+  if (!lmc_handle_error(write(mc->fd, "", 1) != 1, "write", 
+      "ShmError", e)) goto failed;
   mc->base = mmap(0, mc->size, PROT_READ | PROT_WRITE, MAP_SHARED, mc->fd, 
       (off_t)0);
-  if (!lmc_handle_error(mc->base == MAP_FAILED, "mmap", e))  goto failed;
+  if (!lmc_handle_error(mc->base == MAP_FAILED, "mmap", "ShmError", e)) 
+     goto failed;
   return mc;
 
 failed:
@@ -85,7 +101,8 @@ open_failed:
 }
 
 int lmc_shm_destroy(lmc_shm_t *mc, lmc_error_t *e) {
-  int r = lmc_handle_error(munmap(mc->base, mc->size) == -1, "munmap", e);
+  int r = lmc_handle_error(munmap(mc->base, mc->size) == -1, "munmap", 
+      "ShmError", e);
   close(mc->fd);
   free(mc);
   return r;

data/src/lmc_shm.h

@@ -18,5 +18,6 @@ lmc_shm_t *lmc_shm_create(const char *namespace, size_t size, int use_persistenc
     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);
 int lmc_clean_namespace(const char *ns, lmc_error_t *e);
 #endif

data/src/lmc_valloc.c

@@ -12,20 +12,17 @@
 #include <sys/mman.h>
 
 #include "lmc_valloc.h"
-
 #include "lmc_lock.h"
+#include "lmc_common.h"
 
-typedef struct {
-  size_t next;
-  size_t size;
-} mem_chunk_descriptor_t;
+#undef lmc_valloc 
 
-mem_chunk_descriptor_t *md_first_free(void *base) {
-  mem_descriptor_t *md = base;
+lmc_mem_chunk_descriptor_t *md_first_free(void *base) {
+  lmc_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) {
+void lmc_dump_chunk(void *base, lmc_mem_chunk_descriptor_t* c) {
   size_t va_c = (void *)c - base;
   printf("chunk %zd:\n"
       "  start: %zd\n"
@@ -36,7 +33,7 @@ void lmc_dump_chunk(void *base, mem_chunk_descriptor_t* c) {
       , 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) {
+void lmc_dump_chunk_brief(char *who, void *base, lmc_mem_chunk_descriptor_t* c) {
   if (!c) { return; }
   size_t va_c = (void *)c - base;
   printf("[%s] chunk %zd:\n", who, va_c);
@@ -44,7 +41,7 @@ void lmc_dump_chunk_brief(char *who, void *base, mem_chunk_descriptor_t* c) {
 
 
 void lmc_dump(void *base) {
-  mem_chunk_descriptor_t* c = md_first_free(base);
+  lmc_mem_chunk_descriptor_t* c = md_first_free(base);
   size_t free = 0;
   long chunks = 0;
   while (c) { 
@@ -55,22 +52,23 @@ void lmc_dump(void *base) {
   }
 }
 
-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);
+int lmc_is_va_valid(void *base, size_t va) {
+  lmc_mem_descriptor_t *md = base;
+  lmc_mem_chunk_descriptor_t* c = base + va;
+  return !(((void *)c < base ) || 
+      (base + md->total_size + sizeof(lmc_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;
+lmc_mem_status_t lmc_status(void *base, char *where) {
+  lmc_mem_descriptor_t *md = base;
+  lmc_mem_chunk_descriptor_t* c = md_first_free(base);
+  lmc_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)) {
+    if (!lmc_is_va_valid(base, (void *)c - base)) {
       printf("[%s] invalid pointer detected: %ld...\n", where, (void *)c - base);
       lmc_dump(base);
       abort();
@@ -88,13 +86,13 @@ mem_status_t lmc_status(void *base, char *where) {
 }
 
 void lmc_show_status(void *base) {
-  mem_status_t ms = lmc_status(base, "lmc_ss");
+  lmc_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;
+  lmc_mem_descriptor_t *md = base;
   if (md->magic == 0xF00D) {
 #ifdef LMC_DEBUG_ALLOC
     printf("memory already initialized, skipping...\n");
@@ -105,14 +103,14 @@ int is_lmc_already_initialized(void *base) {
 }
 
 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);
+  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;
   md->total_size = s;
-  mem_chunk_descriptor_t *c = ptr + sizeof(mem_descriptor_t);
+  lmc_mem_chunk_descriptor_t *c = ptr + sizeof(lmc_mem_descriptor_t);
   c->next = 0;
   c->size = s;
 }
@@ -121,7 +119,7 @@ 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 __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); }
@@ -135,15 +133,15 @@ size_t __s(char *where, mem_status_t ms, size_t mem_before, size_t expected_diff
 }
 
 size_t lmc_valloc(void *base, size_t size) {
-  mem_descriptor_t *md = base;
-  // MOD by power of 2
+  lmc_mem_descriptor_t *md = base;
+  // idea: MOD by power of 2
   size_t s = lmc_max(size + sizeof(size_t), 
-      sizeof(mem_chunk_descriptor_t) + sizeof(size_t));
+      sizeof(lmc_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;
+  lmc_mem_chunk_descriptor_t *c = md_first_free(base);
+  lmc_mem_chunk_descriptor_t *p = NULL;
   if (size == 0) { return 0; }
-  while (c && c->size <s ) { 
+  while (c && c->size < s ) { 
     p = c;
     if (c->next == 0) {
       c = 0;
@@ -156,13 +154,14 @@ size_t lmc_valloc(void *base, size_t size) {
     return 0;
   }
   size_t r = 0;
-  if (c->size - s < sizeof(mem_chunk_descriptor_t)) { s = c->size; }
+  if (c->size - s < sizeof(lmc_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; }
+    LMC_TEST_CRASH
     r = (size_t)((void*)c - (void*)base);
   } else {
   // -----------------           -------------------
@@ -170,6 +169,7 @@ size_t lmc_valloc(void *base, size_t size) {
   // |               |           -------------------
   // -----------------           
     c->size -= s;
+    LMC_TEST_CRASH
     r = (size_t)((void*)c - base) + c->size;
   }
   *(size_t *)(r + base) = s;
@@ -178,12 +178,12 @@ size_t lmc_valloc(void *base, size_t size) {
 
 // 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;
+  lmc_mem_descriptor_t *md = base;
+  lmc_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;
+  lmc_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;
@@ -208,9 +208,13 @@ void lmc_check_coalesce(void *base, size_t va_chunk) {
         // ----------------------
         if (va_chunk + c_size == va_c_free_chunk) { 
           chunk->size += c_free_chunk->size;
+          LMC_TEST_CRASH
           if (chunk->next == va_c_free_chunk) { va_previous = va_chunk; }
-          mem_chunk_descriptor_t *p = va_previous ? base + va_previous : 0;
+          LMC_TEST_CRASH
+          lmc_mem_chunk_descriptor_t *p = va_previous ? base + va_previous : 0;
+          LMC_TEST_CRASH
           if (p) { p->next = c_free_chunk->next; }
+          LMC_TEST_CRASH
           break;
         }
       }
@@ -226,42 +230,33 @@ void lmc_check_coalesce(void *base, size_t va_chunk) {
   // | 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;
+    lmc_mem_chunk_descriptor_t *cd = base + merge1_chunk;
+    lmc_mem_chunk_descriptor_t *p = va_chunk_p ? base + va_chunk_p : 0;
+    lmc_mem_chunk_descriptor_t *vacd = va_chunk? base + va_chunk : 0;
+    LMC_TEST_CRASH
     if (p) { p->next = vacd->next; }
+    LMC_TEST_CRASH
     if (md->first_free == va_chunk) { md->first_free = chunk->next; }
+    LMC_TEST_CRASH
     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 __lmc_free(void *base, size_t va_used_chunk, size_t uc_size) {
   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;
+  lmc_mem_descriptor_t *md = base;
+  lmc_mem_chunk_descriptor_t *mcd_used_chunk = used_chunk_p;
   size_t va_c_free_chunk = 0;
-  mem_chunk_descriptor_t* c_free_chunk = base + va_c_free_chunk;
+  lmc_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));
+  memset(base + va_used_chunk - sizeof(size_t), 0xF9, uc_size - sizeof(size_t));
 #endif
   int freed = 0;
   while (c_free_chunk) {
@@ -274,7 +269,9 @@ void lmc_free(void *base, size_t chunk) {
     // ----------------------
     if (va_c_free_end == va_used_chunk) { 
       freed = 1;
+      LMC_TEST_CRASH
       c_free_chunk->size += uc_size;
+      LMC_TEST_CRASH
       lmc_check_coalesce(base, va_c_free_chunk);
       break;
     } else 
@@ -285,7 +282,7 @@ void lmc_free(void *base, size_t chunk) {
     // ----------------------
     if (va_used_chunk + uc_size == va_c_free_chunk) { 
       freed = 1;
-      mem_chunk_descriptor_t *p = base + va_previous;
+      lmc_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;
@@ -318,7 +315,162 @@ void lmc_free(void *base, size_t chunk) {
 #endif
 }
 
+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; }
+  if (!(chunk >= sizeof(lmc_mem_descriptor_t) + sizeof(size_t)) ||
+      !lmc_is_va_valid(base, chunk)) {
+    printf("lmc_free: Invalid pointer: %zd\n", chunk);
+    return;
+  }
+  size_t va_used_chunk = chunk - sizeof(size_t);
+  void *used_chunk_p = base + va_used_chunk;
+  size_t uc_size = *(size_t *)used_chunk_p;
+  __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;
+}
+
+void lmc_um_setbit(char *bf, int i, int v) {
+  bf += i / 8;
+  if (v) *bf |= 1 << (i % 8);    
+  else *bf &= ~(1 << (i % 8));  
+}
+
+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;
+  size_t gap_count = 0;
+  size_t space = 0;
+  memset(&m, 0xFF, sizeof(m));
+  for (i = 0; i < md->total_size; ++i) { 
+    if (!gap) {
+      size_t *b = (void *)bf + i / 8;
+      while (*b == m && i < md->total_size - sizeof(size_t)) { 
+        i += sizeof(size_t) * 8; b++; 
+      }
+    }
+    if (lmc_um_getbit(bf, i) == 0) {
+      if (!gap) {
+        gs = i;
+        gap = 1;
+        gap_count++;
+      }
+    } else {
+      if (gap) {
+        gap = 0;
+        space += i - gs;
+        __lmc_free(base, gs, i - gs);
+      }
+    }
+  }
+  if (gap) {
+    gap = 0;
+    space += i - gs;
+    __lmc_free(base, gs, i - gs);
+  }
+  //printf("total leaks: %zd block, %zd bytes total\n", gap_count, space);
+  return 1;
+}
+
+int lmc_um_check_unmarked(void *base, char *bf, size_t va, size_t size) {
+  size_t i;
+  size_t n;
+  memset(&n, 0x0, sizeof(n));
+  size_t end = va + size;
+  for (i = va; i < va + size; ++i) { 
+    size_t *b = (void *)bf + i / 8;
+    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;
+    }
+  }
+  return 1;
+}
+
+int lmc_um_mark(void *base, char *bf, size_t va, size_t size) {
+  size_t i;
+  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", 
+        va, va + size, md->total_size);
+    return 0;
+  }
+  if (!lmc_um_check_unmarked(base, bf, va, size)) return 0;
+  for (i = va; i < va + size; ++i) { 
+    if (i % 8 == 0) {
+      size_t b_start = i / 8;
+      size_t b_end = (va + size - 1) / 8;
+      if (b_start != b_end) {
+        memset(bf + b_start, 0xFF, b_end - b_start);
+        i += (b_end * 8) - va;
+      }
+    }
+    lmc_um_setbit(bf, i, 1); 
+  }
+  return 1;
+}
+
+int lmc_um_mark_allocated(void *base, char *bf, size_t va) {
+  size_t real_va = va - sizeof(size_t);
+  size_t s = *(size_t *)(base + real_va);
+  return lmc_um_mark(base, bf, real_va, s);
+}
+
+char *lmc_um_new_mem_usage_bitmap(void *base) {
+  lmc_mem_descriptor_t *md = base;
+  size_t ts = ((md->total_size + 7) / 8);
+  char *bf = calloc(1, ts);
+  size_t va = md->first_free;
+  if (!lmc_um_mark(base, bf, 0, sizeof(lmc_mem_descriptor_t))) goto failed;
+  lmc_mem_chunk_descriptor_t *c;
+  while (va) { 
+    c = base + va;
+    if (!lmc_um_mark(base, bf, va, c->size)) goto failed;
+    va = c->next;
+  }
+  return bf;
+
+failed:
+  free(bf);
+  return 0;
+}
+
+lmc_log_descriptor_t *lmc_log_op(void *base, int opid) {
+  lmc_mem_descriptor_t *md = base;
+  lmc_log_descriptor_t *l = &md->log;
+  l->op_id  = opid;
+  l->p1 = l->p2 = 0x0;
+  return l;
+}
+
+void lmc_log_finish(void *base) {
+  lmc_mem_descriptor_t *md = base;
+  lmc_log_descriptor_t *l = &md->log;
+  l->op_id = 0;
+  l->p1 = l->p2 = 0x0;
+}