Use a thread pool for inode fetches, and remove some debugging output.

diff --git a/bluesky/bluesky.h b/bluesky/bluesky.h
index 834097f..4dab234 100644 (file)
--- a/bluesky/bluesky.h
+++ b/bluesky/bluesky.h
@@ -191,6 +191,9 @@ typedef struct {
 
     /* Queue for asynchronous cloudlog unrefs, where needed. */
     GAsyncQueue *unref_queue;
+
+    /* Thread pool for asynchronous inode fetches */
+    GThreadPool *inode_fetch_thread_pool;
 } BlueSkyFS;
 
 /* Inode number of the root directory. */

diff --git a/bluesky/imap.c b/bluesky/imap.c
index 24144b4..4d22350 100644 (file)
--- a/bluesky/imap.c
+++ b/bluesky/imap.c
@@ -110,7 +110,8 @@ InodeMapEntry *bluesky_inode_map_lookup(GSequence *inode_map, uint64_t inum,
         entry->inum = inum;
         g_sequence_insert_sorted(range->map_entries, entry, compare, NULL);
 
-        g_print("Created inode map entry for %"PRIu64"\n", inum);
+        if (bluesky_verbose)
+            g_print("Created inode map entry for %"PRIu64"\n", inum);
     }
 
     if (action != 0) {

diff --git a/bluesky/inode.c b/bluesky/inode.c
index 0d40da4..7ace60d 100644 (file)
--- a/bluesky/inode.c
+++ b/bluesky/inode.c
@@ -14,6 +14,8 @@
 
 #include "bluesky-private.h"
 
+static void inode_fetch_task(gpointer a, gpointer b);
+
 /* Core filesystem.  Different proxies, such as the NFSv3 one, interface to
  * this, but the core actually tracks the data which is stored.  So far we just
  * implement an in-memory filesystem, but eventually this will be state which
@@ -95,6 +97,9 @@ BlueSkyFS *bluesky_new_fs(gchar *name)
     fs->log_state->data = g_string_new("");
 
     bluesky_cloudlog_threads_init(fs);
+    fs->inode_fetch_thread_pool = g_thread_pool_new(inode_fetch_task, NULL,
+                                                    bluesky_max_threads,
+                                                    FALSE, NULL);
 
     return fs;
 }
@@ -346,8 +351,10 @@ void bluesky_inode_do_sync(BlueSkyInode *inode)
     }
 }
 
-static void complete_inode_fetch(BlueSkyInode *inode)
+static void inode_fetch_task(gpointer a, gpointer b)
 {
+    BlueSkyInode *inode = (BlueSkyInode *)a;
+
     BlueSkyCloudLog *item = inode->committed_item;
     inode->committed_item = NULL;
     g_print("Completing fetch of inode %"PRIu64"...\n", inode->inum);
@@ -380,15 +387,18 @@ void bluesky_inode_fetch(BlueSkyFS *fs, uint64_t inum)
     if (entry == NULL)
         return;
 
+    /* Non-portable behavior: We take the inode lock here, and release it in
+     * the fetching thread.  This works with the default Linux pthreads
+     * implementation but is not guaranteed. */
+
     BlueSkyInode *inode = bluesky_new_inode(inum, fs, BLUESKY_PENDING);
     inode->change_count = 0;
     bluesky_inode_ref(inode);       // Extra ref held by fetching process
     g_mutex_lock(inode->lock);
-    bluesky_insert_inode(fs, inode);
+
     inode->committed_item = entry->item;
     bluesky_cloudlog_ref(entry->item);
+    bluesky_insert_inode(fs, inode);
 
-    /* TODO: Thread pool or other better async method. */
-    g_thread_create((GThreadFunc)complete_inode_fetch,
-                    (gpointer)inode, FALSE, NULL);
+    g_thread_pool_push(fs->inode_fetch_thread_pool, inode, NULL);
 }

diff --git a/nfs3/nfsd.c b/nfs3/nfsd.c
index fc1f955..f9cbd7f 100644 (file)
--- a/nfs3/nfsd.c
+++ b/nfs3/nfsd.c
@@ -53,8 +53,6 @@ int main(int argc, char *argv[])
 
     register_rpc();
 
-    bluesky_debug_dump(fs);
-
     svc_run();
     fprintf(stderr, "%s", "svc_run returned");
     exit(1);