refcounter: delete, use rwlock instead

Makefile

@@ -37,7 +37,6 @@ ifneq ($(SNAPPY),0)
 endif
 
 OBJS += src/threads.o
-OBJS += src/refcounter.o
 OBJS += src/compressor.o
 OBJS += src/utils.o
 OBJS += src/writer.o
@@ -49,7 +48,6 @@ DEPS=
 DEPS += include/bplus.h
 DEPS += include/private/errors.h
 DEPS += include/private/threads.h
-DEPS += include/private/refcounter.h
 DEPS += include/private/pages.h
 DEPS += include/private/values.h
 DEPS += include/private/tree.h

include/private/errors.h

@@ -14,8 +14,9 @@
 #define BP_ECOMP 0x201
 #define BP_EDECOMP 0x202
 
-#define BP_EALLOC 0x301
-#define BP_EMUTEX 0x302
+#define BP_EALLOC  0x301
+#define BP_EMUTEX  0x302
+#define BP_ERWLOCK 0x303
 
 #define BP_ENOTFOUND  0x401
 #define BP_ESPLITPAGE 0x402

include/private/threads.h

@@ -8,13 +8,20 @@ extern "C" {
 #include <pthread.h>
 
 typedef pthread_mutex_t bp__mutex_t;
+typedef pthread_rwlock_t bp__rwlock_t;
 
 
 int bp__mutex_init(bp__mutex_t* mutex);
 void bp__mutex_destroy(bp__mutex_t* mutex);
 void bp__mutex_lock(bp__mutex_t* mutex);
 void bp__mutex_unlock(bp__mutex_t* mutex);
 
+int bp__rwlock_init(bp__rwlock_t* rwlock);
+void bp__rwlock_destroy(bp__rwlock_t* rwlock);
+void bp__rwlock_rdlock(bp__rwlock_t* rwlock);
+void bp__rwlock_wrlock(bp__rwlock_t* rwlock);
+void bp__rwlock_unlock(bp__rwlock_t* rwlock);
+
 #ifdef __cplusplus
 } /* extern "C" */
 #endif

include/private/tree.h

@@ -5,25 +5,22 @@
 extern "C" {
 #endif
 
+#include "private/threads.h"
 #include "private/writer.h"
 #include "private/pages.h"
 
 #define BP__HEAD_SIZE sizeof(uint64_t) * 4
 
 #define BP_TREE_PRIVATE\
     BP_WRITER_PRIVATE\
+    bp__rwlock_t rwlock;\
     bp__tree_head_t head;\
     bp_compare_cb compare_cb;
 
 typedef struct bp__tree_head_s bp__tree_head_t;
 
-enum bp__destroy_type {
-  kNoClose,
-  kClose
-};
-
 int bp__init(bp_db_t* tree);
-void bp__destroy(bp_db_t* tree, const enum bp__destroy_type type);
+void bp__destroy(bp_db_t* tree);
 
 int bp__tree_read_head(bp__writer_t* w, void* data);
 int bp__tree_write_head(bp__writer_t* w, void* data);

include/private/writer.h

@@ -2,7 +2,6 @@
 #define _PRIVATE_WRITER_H_
 
 #include <stdint.h>
-#include "private/refcounter.h"
 #include "private/threads.h"
 
 #ifdef __cplusplus
@@ -13,7 +12,6 @@ extern "C" {
 #define _XOPEN_SOURCE 600
 
 #define BP_WRITER_PRIVATE \
-    BP__REF_PRIVATE\
     int fd;\
     char* filename;\
     uint64_t filesize;\
@@ -29,8 +27,6 @@ enum comp_type {
 
 int bp__writer_create(bp__writer_t* w, const char* filename);
 int bp__writer_destroy(bp__writer_t* w);
-int bp__writer_open(bp__writer_t* w, const char* filename);
-int bp__writer_close(bp__writer_t* w);
 
 int bp__writer_fsync(bp__writer_t* w);
 

src/bplus.c

@@ -7,22 +7,29 @@
 
 int bp_open(bp_db_t* tree, const char* filename) {
   int ret;
-  ret = bp__writer_create((bp__writer_t*) tree, filename);
+
+  ret = bp__rwlock_init(&tree->rwlock);
   if (ret != BP_OK) return ret;
 
+  ret = bp__writer_create((bp__writer_t*) tree, filename);
+  if (ret != BP_OK) goto fatal;
+
   tree->head.page = NULL;
 
-  return bp__init(tree);
-}
+  ret = bp__init(tree);
+  if (ret != BP_OK) goto fatal;
 
+  return BP_OK;
 
-int bp_close(bp_db_t* tree) {
-  int ret;
+fatal:
+  bp__rwlock_destroy(&tree->rwlock);
+  return ret;
+}
 
-  ret = bp__writer_destroy((bp__writer_t*) tree);
-  if (ret != BP_OK) return ret;
 
-  bp__destroy(tree, kNoClose);
+int bp_close(bp_db_t* tree) {
+  bp__rwlock_destroy(&tree->rwlock);
+  bp__destroy(tree);
 
   return BP_OK;
 }
@@ -50,10 +57,8 @@ int bp__init(bp_db_t* tree) {
 }
 
 
-void bp__destroy(bp_db_t* tree, const enum bp__destroy_type type) {
-  if (type == kClose) {
-    bp__writer_close((bp__writer_t*) tree);
-  }
+void bp__destroy(bp_db_t* tree) {
+  bp__writer_destroy((bp__writer_t*) tree);
   if (tree->head.page != NULL) {
     bp__page_destroy(tree, tree->head.page);
     tree->head.page = NULL;
@@ -64,11 +69,11 @@ void bp__destroy(bp_db_t* tree, const enum bp__destroy_type type) {
 int bp_get(bp_db_t* tree, const bp_key_t* key, bp_value_t* value) {
   int ret;
 
-  bp__ref((bp__ref_t*) tree);
+  bp__rwlock_rdlock(&tree->rwlock);
 
   ret = bp__page_get(tree, tree->head.page, key, value);
 
-  bp__unref((bp__ref_t*) tree);
+  bp__rwlock_unlock(&tree->rwlock);
 
   return ret;
 }
@@ -90,13 +95,13 @@ int bp_get_previous(bp_db_t* tree,
 int bp_set(bp_db_t* tree, const bp_key_t* key, const bp_value_t* value) {
   int ret;
 
-  bp__ref_close((bp__ref_t*) tree);
+  bp__rwlock_wrlock(&tree->rwlock);
 
   ret = bp__page_insert(tree, tree->head.page, key, value);
   if (ret != BP_OK) return ret;
   ret = bp__tree_write_head((bp__writer_t*) tree, NULL);
 
-  bp__ref_open((bp__ref_t*) tree);
+  bp__rwlock_unlock(&tree->rwlock);
 
   return ret;
 }
@@ -111,7 +116,7 @@ int bp_bulk_set(bp_db_t* tree,
   bp_value_t* values_iter = (bp_value_t*) *values;
   uint64_t left = count;
 
-  bp__ref_close((bp__ref_t*) tree);
+  bp__rwlock_wrlock(&tree->rwlock);
 
   ret = bp__page_bulk_insert(tree,
                              tree->head.page,
@@ -122,7 +127,7 @@ int bp_bulk_set(bp_db_t* tree,
   if (ret != BP_OK) return ret;
   ret =  bp__tree_write_head((bp__writer_t*) tree, NULL);
 
-  bp__ref_open((bp__ref_t*) tree);
+  bp__rwlock_unlock(&tree->rwlock);
 
   return ret;
 }
@@ -131,13 +136,13 @@ int bp_bulk_set(bp_db_t* tree,
 int bp_remove(bp_db_t* tree, const bp_key_t* key) {
   int ret;
 
-  bp__ref_close((bp__ref_t*) tree);
+  bp__rwlock_wrlock(&tree->rwlock);
 
   ret = bp__page_remove(tree, tree->head.page, key);
   if (ret != BP_OK) return ret;
   ret = bp__tree_write_head((bp__writer_t*) tree, NULL);
 
-  bp__ref_open((bp__ref_t*) tree);
+  bp__rwlock_unlock(&tree->rwlock);
 
   return ret;
 }
@@ -160,12 +165,12 @@ int bp_compact(bp_db_t* tree) {
   /* destroy stub head page */
   bp__page_destroy(&compacted, compacted.head.page);
 
-  bp__ref((bp__ref_t*) tree);
+  bp__rwlock_rdlock(&tree->rwlock);
 
   /* clone source tree's head page */
   ret = bp__page_clone(&compacted, tree->head.page, &compacted.head.page);
 
-  bp__unref((bp__ref_t*) tree);
+  bp__rwlock_unlock(&tree->rwlock);
 
   /* copy all pages starting from head */
   ret = bp__page_copy(tree, &compacted, compacted.head.page);
@@ -175,11 +180,11 @@ int bp_compact(bp_db_t* tree) {
   compacted.head.page = NULL;
   if (ret != BP_OK) return ret;
 
-  bp__ref_close((bp__ref_t*) tree);
+  bp__rwlock_wrlock(&tree->rwlock);
 
   ret = bp__writer_compact_finalize((bp__writer_t*) tree,
                                     (bp__writer_t*) &compacted);
-  bp__ref_open((bp__ref_t*) tree);
+  bp__rwlock_unlock(&tree->rwlock);
 
   return ret;
 }
@@ -193,7 +198,7 @@ int bp_get_filtered_range(bp_db_t* tree,
                           void* arg) {
   int ret;
 
-  bp__ref((bp__ref_t*) tree);
+  bp__rwlock_rdlock(&tree->rwlock);
 
   ret = bp__page_get_range(tree,
                            tree->head.page,
@@ -203,7 +208,7 @@ int bp_get_filtered_range(bp_db_t* tree,
                            cb,
                            arg);
 
-  bp__unref((bp__ref_t*) tree);
+  bp__rwlock_unlock(&tree->rwlock);
 
   return ret;
 }