Make kvstore backend in BlueSky asynchronous.

[bluesky.git] / bluesky / store.c

diff --git a/bluesky/store.c b/bluesky/store.c
index cc8a5e4..8cf9f0e 100644 (file)
--- a/bluesky/store.c
+++ b/bluesky/store.c
@@ -88,6 +88,11 @@ BlueSkyStoreAsync *bluesky_store_async_new(BlueSkyStore *store)
     return async;
 }
 
+gpointer bluesky_store_async_get_handle(BlueSkyStoreAsync *async)
+{
+    return async->store->handle;
+}
+
 void bluesky_store_async_ref(BlueSkyStoreAsync *async)
 {
     if (async == NULL)
@@ -110,7 +115,6 @@ void bluesky_store_async_unref(BlueSkyStoreAsync *async)
         g_free(async->key);
         bluesky_string_unref(async->data);
         g_free(async);
-        g_print("Freed async\n");
     }
 }
 
@@ -157,6 +161,8 @@ void bluesky_store_async_mark_complete(BlueSkyStoreAsync *async)
 {
     g_return_if_fail(async->status != ASYNC_COMPLETE);
 
+    bluesky_time_hires elapsed = bluesky_now_hires() - async->start_time;
+
     g_mutex_lock(async->store->lock);
     async->store->pending--;
     if (async->store->pending == 0)
@@ -171,20 +177,29 @@ void bluesky_store_async_mark_complete(BlueSkyStoreAsync *async)
         async->notifiers = nl->next;
         g_thread_pool_push(notifier_thread_pool, nl, NULL);
     }
-}
 
-static void test_notifier(gpointer a, gpointer u)
-{
-    g_print("Notifier called!\n");
+    g_log("bluesky/store", G_LOG_LEVEL_DEBUG,
+          "[%p] complete: elapsed = %"PRIi64" ns",
+          async, elapsed);
 }
 
 void bluesky_store_async_submit(BlueSkyStoreAsync *async)
 {
     BlueSkyStore *store = async->store;
 
+    async->start_time = bluesky_now_hires();
+
+    g_log("bluesky/store", G_LOG_LEVEL_DEBUG, "[%p] submit: %s %s",
+          async,
+          async->op == STORE_OP_GET ? "GET"
+            : async->op == STORE_OP_PUT ? "PUT"
+            : async->op == STORE_OP_DELETE ? "DELETE"
+            : async->op == STORE_OP_BARRIER ? "BARRIER" : "???",
+          async->key);
+
     /* Barriers are handled specially, and not handed down the storage
      * implementation layer. */
-    if (async->op = STORE_OP_BARRIER) {
+    if (async->op == STORE_OP_BARRIER) {
         async->status = ASYNC_RUNNING;
         if (GPOINTER_TO_INT(async->store_private) == 0)
             bluesky_store_async_mark_complete(async);
@@ -195,7 +210,6 @@ void bluesky_store_async_submit(BlueSkyStoreAsync *async)
     async->store->pending++;
     g_mutex_unlock(async->store->lock);
 
-    bluesky_store_async_add_notifier(async, test_notifier, NULL);
     store->impl->submit(store->handle, async);
 
     if (bluesky_options.synchronous_stores)
@@ -204,9 +218,9 @@ void bluesky_store_async_submit(BlueSkyStoreAsync *async)
 
 static void op_complete(gpointer a, gpointer b)
 {
-    BlueSkyStoreAsync *async = (BlueSkyStoreAsync *)a;
     BlueSkyStoreAsync *barrier = (BlueSkyStoreAsync *)b;
 
+    bluesky_store_async_ref(barrier);
     g_mutex_lock(barrier->lock);
     barrier->store_private
         = GINT_TO_POINTER(GPOINTER_TO_INT(barrier->store_private) - 1);
@@ -215,6 +229,7 @@ static void op_complete(gpointer a, gpointer b)
         bluesky_store_async_mark_complete(barrier);
     }
     g_mutex_unlock(barrier->lock);
+    bluesky_store_async_unref(barrier);
 }
 
 /* Add the given operation to the barrier.  The barrier will not complete until
@@ -225,7 +240,7 @@ void bluesky_store_add_barrier(BlueSkyStoreAsync *barrier,
     g_return_if_fail(barrier->op == STORE_OP_BARRIER);
     barrier->store_private
         = GINT_TO_POINTER(GPOINTER_TO_INT(barrier->store_private) + 1);
-    bluesky_store_async_add_notifier(async, op_complete, NULL);
+    bluesky_store_async_add_notifier(async, op_complete, barrier);
 }
 
 static void notifier_task(gpointer n, gpointer s)
@@ -278,7 +293,6 @@ void bluesky_store_put(BlueSkyStore *store,
     bluesky_store_async_unref(async);
 }
 
-#if 0
 /* Simple in-memory data store for test purposes. */
 typedef struct {
     GMutex *lock;
@@ -319,11 +333,37 @@ static void memstore_put(gpointer s, const gchar *key, BlueSkyRCStr *val)
     g_hash_table_insert(store->store, g_strdup(key), val);
 }
 
+static void memstore_submit(gpointer s, BlueSkyStoreAsync *async)
+{
+    g_return_if_fail(async->status == ASYNC_NEW);
+    g_return_if_fail(async->op != STORE_OP_NONE);
+
+    switch (async->op) {
+    case STORE_OP_GET:
+        async->data = memstore_get(s, async->key);
+        break;
+
+    case STORE_OP_PUT:
+        memstore_put(s, async->key, async->data);
+        break;
+
+    default:
+        g_warning("Uknown operation type for MemStore: %d\n", async->op);
+        return;
+    }
+
+    bluesky_store_async_mark_complete(async);
+}
+
+static void memstore_cleanup(gpointer store, BlueSkyStoreAsync *async)
+{
+}
+
 static BlueSkyStoreImplementation memstore_impl = {
     .create = memstore_create,
     .destroy = memstore_destroy,
-    .get = memstore_get,
-    .put = memstore_put,
+    .submit = memstore_submit,
+    .cleanup = memstore_cleanup,
 };
 
 /* Store implementation which writes data as files to disk. */
@@ -336,7 +376,7 @@ static void filestore_destroy()
 {
 }
 
-static BlueSkyRCStr *filestore_get(gpointer s, const gchar *key)
+static BlueSkyRCStr *filestore_get(const gchar *key)
 {
     gchar *contents = NULL;
     gsize length;
@@ -349,24 +389,51 @@ static BlueSkyRCStr *filestore_get(gpointer s, const gchar *key)
     return bluesky_string_new(contents, length);
 }
 
-static void filestore_put(gpointer s, const gchar *key, BlueSkyRCStr *val)
+static void filestore_put(const gchar *key, BlueSkyRCStr *val)
 {
     g_file_set_contents(key, val->data, val->len, NULL);
 }
 
+static void filestore_submit(gpointer s, BlueSkyStoreAsync *async)
+{
+    g_return_if_fail(async->status == ASYNC_NEW);
+    g_return_if_fail(async->op != STORE_OP_NONE);
+
+    switch (async->op) {
+    case STORE_OP_GET:
+        async->data = filestore_get(async->key);
+        async->result = 0;
+        break;
+
+    case STORE_OP_PUT:
+        filestore_put(async->key, async->data);
+        async->result = 0;
+        break;
+
+    default:
+        g_warning("Uknown operation type for FileStore: %d\n", async->op);
+        return;
+    }
+
+    bluesky_store_async_mark_complete(async);
+}
+
+static void filestore_cleanup(gpointer store, BlueSkyStoreAsync *async)
+{
+}
+
 static BlueSkyStoreImplementation filestore_impl = {
     .create = filestore_create,
     .destroy = filestore_destroy,
-    .get = filestore_get,
-    .put = filestore_put,
+    .submit = filestore_submit,
+    .cleanup = filestore_cleanup,
 };
-#endif
 
 void bluesky_store_init()
 {
     store_implementations = g_hash_table_new(g_str_hash, g_str_equal);
     notifier_thread_pool = g_thread_pool_new(notifier_task, NULL, -1, FALSE,
                                              NULL);
-    //bluesky_store_register(&memstore_impl, "mem");
-    //bluesky_store_register(&filestore_impl, "file");
+    bluesky_store_register(&memstore_impl, "mem");
+    bluesky_store_register(&filestore_impl, "file");
 }