use item lock instead of global lock when hash expanding.

Author: zwChan

assoc.c

@@ -146,6 +146,12 @@ static void assoc_expand(void) {
 static void assoc_start_expand(void) {
     if (started_expanding)
         return;
+
+    /*With this condition, we can expanding holding only one item lock,
+     * and it should always be false*/
+    if (item_lock_hashpower >= hashpower)
+        return;
+
     started_expanding = true;
     pthread_cond_signal(&maintenance_cond);
 }
@@ -206,54 +212,57 @@ static void *assoc_maintenance_thread(void *arg) {
     while (do_run_maintenance_thread) {
         int ii = 0;
 
-        /* Lock the cache, and bulk move multiple buckets to the new
-         * hash table. */
-        item_lock_global();
-        mutex_lock(&cache_lock);
-
+        /* As there is only one thread process expanding, and we hold the item
+         * lock, it seems not necessary to hold the cache_lock . */
         for (ii = 0; ii < hash_bulk_move && expanding; ++ii) {
             item *it, *next;
             int bucket;
-
-            for (it = old_hashtable[expand_bucket]; NULL != it; it = next) {
-                next = it->h_next;
-
-                bucket = hash(ITEM_key(it), it->nkey) & hashmask(hashpower);
-                it->h_next = primary_hashtable[bucket];
-                primary_hashtable[bucket] = it;
+            void *item_lock = NULL;
+
+            /* bucket = hv & hashmask(hashpower) =>the bucket of hash table
+             * is the lowest N bits of the hv, and the bucket of item_locks is
+             *  also the lowest M bits of hv, and N is greater than M.
+             *  So we can process expanding with only one item_lock. cool! */
+            /*Get item lock for the slot in old hashtable*/
+            if ((item_lock = item_trylock(expand_bucket))) {
+                    for (it = old_hashtable[expand_bucket]; NULL != it; it = next) {
+                        next = it->h_next;
+                        bucket = hash(ITEM_key(it), it->nkey) & hashmask(hashpower);
+                        it->h_next = primary_hashtable[bucket];
+                        primary_hashtable[bucket] = it;
+                    }
+
+                    old_hashtable[expand_bucket] = NULL;
+
+                    expand_bucket++;
+                    if (expand_bucket == hashsize(hashpower - 1)) {
+                        expanding = false;
+                        free(old_hashtable);
+                        STATS_LOCK();
+                        stats.hash_bytes -= hashsize(hashpower - 1) * sizeof(void *);
+                        stats.hash_is_expanding = 0;
+                        STATS_UNLOCK();
+                        if (settings.verbose > 1)
+                            fprintf(stderr, "Hash table expansion done\n");
+                    }
+
+            } else {
+                /*wait for 100ms. since only one expanding thread, it's not
+                 * necessary to sleep a random value*/
+                usleep(100*1000);
             }
 
-            old_hashtable[expand_bucket] = NULL;
-
-            expand_bucket++;
-            if (expand_bucket == hashsize(hashpower - 1)) {
-                expanding = false;
-                free(old_hashtable);
-                STATS_LOCK();
-                stats.hash_bytes -= hashsize(hashpower - 1) * sizeof(void *);
-                stats.hash_is_expanding = 0;
-                STATS_UNLOCK();
-                if (settings.verbose > 1)
-                    fprintf(stderr, "Hash table expansion done\n");
+            if (item_lock) {
+                item_trylock_unlock(item_lock);
+                item_lock = NULL;
             }
         }
 
-        mutex_unlock(&cache_lock);
-        item_unlock_global();
-
         if (!expanding) {
-            /* finished expanding. tell all threads to use fine-grained locks */
-            switch_item_lock_type(ITEM_LOCK_GRANULAR);
-            slabs_rebalancer_resume();
             /* We are done expanding.. just wait for next invocation */
             mutex_lock(&cache_lock);
             started_expanding = false;
             pthread_cond_wait(&maintenance_cond, &cache_lock);
-            /* Before doing anything, tell threads to use a global lock */
-            mutex_unlock(&cache_lock);
-            slabs_rebalancer_pause();
-            switch_item_lock_type(ITEM_LOCK_GLOBAL);
-            mutex_lock(&cache_lock);
             assoc_expand();
             mutex_unlock(&cache_lock);
         }

assoc.h

@@ -7,3 +7,4 @@ void do_assoc_move_next_bucket(void);
 int start_assoc_maintenance_thread(void);
 void stop_assoc_maintenance_thread(void);
 extern unsigned int hashpower;
+extern unsigned int item_lock_hashpower;

thread.c

@@ -56,7 +56,7 @@ static pthread_mutex_t cqi_freelist_lock;
 static pthread_mutex_t *item_locks;
 /* size of the item lock hash table */
 static uint32_t item_lock_count;
-static unsigned int item_lock_hashpower;
+unsigned int item_lock_hashpower;
 #define hashsize(n) ((unsigned long int)1<<(n))
 #define hashmask(n) (hashsize(n)-1)
 /* this lock is temporarily engaged during a hash table expansion */