Memcached源码分析之assoc.c

#include "memcached.h"

#include <sys/stat.h>

#include <sys/socket.h>

#include <sys/signal.h>

#include <sys/resource.h>

#include <fcntl.h>

#include <netinet/in.h>

#include <errno.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <assert.h>

#include <pthread.h>

 

static pthread_cond_t maintenance_cond = PTHREAD_COND_INITIALIZER;

 

 

typedef  unsigned long  int  ub4;   /* unsigned 4-byte quantities */

typedef  unsigned       char ub1;   /* unsigned 1-byte quantities */

 

unsigned int hashpower = HASHPOWER_DEFAULT;

 

#define hashsize(n) ((ub4)1<<(n)) //2^n 次方  默认n是16（上面hashpower）

#define hashmask(n) (hashsize(n)-1) //0x1111 1111 1111 1111

 

static item** primary_hashtable = 0; //主hash表，注意理解，这个表只是存指针，没有存item

 

 

static item** old_hashtable = 0; //旧的hash表，在扩展hash表的时候用到

 

static unsigned int hash_items = 0; //hash表总数

 

static bool expanding = false;    //是不是正在扩展hash表中（通过线程assoc_maintenance_thread）

static bool started_expanding = false;

 

/*

 在扩展时，是以桶为粒度进行的，这是告诉我们扩张到哪个桶了。3

 从0 到 hashsize(hashpower - 1) - 1 

 */

static unsigned int expand_bucket = 0;

 

void assoc_init(const int hashtable_init) {

    if (hashtable_init) {

        hashpower = hashtable_init;

    }

    primary_hashtable = calloc(hashsize(hashpower), sizeof(void *));

    if (! primary_hashtable) {

        fprintf(stderr, "Failed to init hashtable.\n");

        exit(EXIT_FAILURE);

    }

    STATS_LOCK();

    stats.hash_power_level = hashpower;

    stats.hash_bytes = hashsize(hashpower) * sizeof(void *);

    STATS_UNLOCK();

}

 

/**

通过key查找item

*/

item *assoc_find(const char *key, const size_t nkey, const uint32_t hv) {

    item *it;

    unsigned int oldbucket;

 

 

    //hv & hashmask(hashpower)得到的是桶在hash表中的下标

    if (expanding &&

        (oldbucket = (hv & hashmask(hashpower - 1))) >= expand_bucket)

    {

        it = old_hashtable[oldbucket];

    } else {

        it = primary_hashtable[hv & hashmask(hashpower)]; //找出item所在的桶链表的首item

    }

 

    item *ret = NULL;

    int depth = 0;

    //遍历相同桶的链表，直到指定的key名为止。

    while (it) {

        //这里为什么要先判断长度？&&的执行过程是先判断左边，如果不为true，那右边的条件也不用判断了，

        //所以个人认为是为了判断memcmp(key, ITEM_key(it), nkey)的调用

        if ((nkey == it->nkey) && (memcmp(key, ITEM_key(it), nkey) == 0)) {

            ret = it;

            break;

        }

        it = it->h_next;

        ++depth;

    }

    MEMCACHED_ASSOC_FIND(key, nkey, depth);

    return ret;

}

 

/**

这里的查找过程和上面的assoc_find 基本一致，不同的地方在于：

这里返回的是指向 “指向当前item的指针”，并且引用当前item的上一个item的h_next，

所以这里返回的就是当前item在桶链表中的前一个item的h_next，这也是为什么命名叫

_hashitem_before的原因~

*/

 

static item** _hashitem_before (const char *key, const size_t nkey, const uint32_t hv) {

    item **pos;

    unsigned int oldbucket;

 

    if (expanding &&

        (oldbucket = (hv & hashmask(hashpower - 1))) >= expand_bucket)

    {

        pos = &old_hashtable[oldbucket];

    } else {

        pos = &primary_hashtable[hv & hashmask(hashpower)];

    }

 

    while (*pos && ((nkey != (*pos)->nkey) || memcmp(key, ITEM_key(*pos), nkey))) {

        pos = &(*pos)->h_next;

    }

    return pos;

}

 

/**

扩展哈希表

*/

static void assoc_expand(void) {

    old_hashtable = primary_hashtable;

 

    primary_hashtable = calloc(hashsize(hashpower + 1), sizeof(void *));

    if (primary_hashtable) {

        if (settings.verbose > 1)

            fprintf(stderr, "Hash table expansion starting\n");

        hashpower++;

        expanding = true;

        expand_bucket = 0;

        STATS_LOCK();

        stats.hash_power_level = hashpower;

        stats.hash_bytes += hashsize(hashpower) * sizeof(void *);

        stats.hash_is_expanding = 1;

        STATS_UNLOCK();

    } else {

        primary_hashtable = old_hashtable;

        /* Bad news, but we can keep running. */

    }

}

 

/**

主要是唤醒哈希表维护线程，执行哈希表扩展工作。

*/

static void assoc_start_expand(void) {

    if (started_expanding)

        return;

    started_expanding = true;

    /**

     发送一个信号给正在处于阻塞等待状态的哈希表维护线程。见assoc_maintenance_thread

    */

    pthread_cond_signal(&maintenance_cond);

}

 

/* Note: this isn't an assoc_update.  The key must not already exist to call this */

/**

把item插入到hash表

*/

int assoc_insert(item *it, const uint32_t hv) {

    unsigned int oldbucket;

 

//    assert(assoc_find(ITEM_key(it), it->nkey) == 0);  /* shouldn't have duplicately named things defined */

 

    //hv & hashmask(hashpower)得到的是桶在hash表中的下标

 

    if (expanding &&

        (oldbucket = (hv & hashmask(hashpower - 1))) >= expand_bucket)

    {

        it->h_next = old_hashtable[oldbucket];

        old_hashtable[oldbucket] = it;

    } else {

        //哈希表难免会冲突，这里用链表保存相同桶下标的item

        //这里是把新的item放到桶的链表头

        it->h_next = primary_hashtable[hv & hashmask(hashpower)];

        primary_hashtable[hv & hashmask(hashpower)] = it;

    }

 

    hash_items++;

    if (! expanding && hash_items > (hashsize(hashpower) * 3) / 2) {

        //当哈希表中的item数大于哈希表桶数的1.5倍时，开始扩展哈希表

        assoc_start_expand();

    }

 

    MEMCACHED_ASSOC_INSERT(ITEM_key(it), it->nkey, hash_items);

    return 1;

}

 

/**

从哈希表中删除某个item

*/

void assoc_delete(const char *key, const size_t nkey, const uint32_t hv) {

    /**

    调用_hashitem_before取到指向 指向当前item的上一个item的h_next指针

    */

    item **before = _hashitem_before(key, nkey, hv);

 

    //下面利用before指针，把当前item的h_next指向0，把上一个item的h_next指向原来before的h_next达到删除作用

    if (*before) {

        item *nxt;

        hash_items--;

        /* The DTrace probe cannot be triggered as the last instruction

         * due to possible tail-optimization by the compiler

         */

        MEMCACHED_ASSOC_DELETE(key, nkey, hash_items);

        nxt = (*before)->h_next;

        (*before)->h_next = 0;   /* probably pointless, but whatever. */

        *before = nxt;

        return;

    }

    /* Note:  we never actually get here.  the callers don't delete things

       they can't find. */

    assert(*before != 0);

}

 

 

static volatile int do_run_maintenance_thread = 1;

 

#define DEFAULT_HASH_BULK_MOVE 1

int hash_bulk_move = DEFAULT_HASH_BULK_MOVE;

 

/**

哈希表维护线程工作时执行的函数

*/

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);

 

        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;

            }

 

            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");

            }

        }

 

        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);

        }

    }

    return NULL;

}

 

static pthread_t maintenance_tid;

 

/**

启动哈希表维护线程

*/

int start_assoc_maintenance_thread() {

    int ret;

    char *env = getenv("MEMCACHED_HASH_BULK_MOVE");

    if (env != NULL) {

        hash_bulk_move = atoi(env);

        if (hash_bulk_move == 0) {

            hash_bulk_move = DEFAULT_HASH_BULK_MOVE;

        }

    }

    if ((ret = pthread_create(&maintenance_tid, NULL,

                              assoc_maintenance_thread, NULL)) != 0) { //assoc_maintenance_thread为线程执行入口

        fprintf(stderr, "Can't create thread: %s\n", strerror(ret));

        return -1;

    }

    return 0;

}

 

/**

停止哈希表维护线程，在memcached服务退出时执行，见memcached.c中main函数，event_base_loop之后

*/

void stop_assoc_maintenance_thread() {

    mutex_lock(&cache_lock);

 

    /**

    发送信号assoc_maintenance_thread进入while循环相应的上下文，

    而设置do_run_maintenance_thread = 0让线程在下次while(do_run_maintenance_thread)语句

    中退出循环，线程退出。

    */

    do_run_maintenance_thread = 0;

    pthread_cond_signal(&maintenance_cond); 

    mutex_unlock(&cache_lock);

 

    pthread_join(maintenance_tid, NULL); //等待线程退出

}