memcached源码阅读

memcached简介：

memcached是一套分布式的快取系统，当初是Danga Interactive为了LiveJournal所发展的，但目前被许多软件（如MediaWiki）所使用。这是一套开放源代码软件，以BSD license授权释出。

 

作者：

 

Anatoly Vorobey <mellon@pobox.com>                                                                                                                          

Brad Fitzpatrick <brad@danga.com>

 

 

源码地址：

http://github.com/memcached/memcached

 

模块分解：

个人感觉memcached的源码可以分为三个部分：

1. 协议，即通信模块，包括如何监听socket，创建连接，解析命令等等；

2. 内存管理，主要负责内存分配，回收

3. 散列管理，负责对存储的内容进行散列，维护散列表

接下来从每个模块来分析memcached的源码：

 

协议模块：

主要代码逻辑位于memcached.c文件中。主要的逻辑就是监听某个端口，发起的连接有多个线程进行处理（round-robin），每个线程处理的连接会去解析socket流中的数据，从中剥离命令类型、数据等等内容。这块主要会用到libevent这个框架进行事件的监听并回调自己定义好的函数。

 

之后就是解析socket流中的数据，这块代码很庞大，但是没有仔细阅读的必要，大体的函数调用顺序如下（以get操作为例）：

event_handler --> drive_machine --> try_read_command --> process_command --> process_get_command -->item_get

在取得item数据后写回socket。

 

内存管理：

memcached的内存分配策略会把内存分成一页一页的内容，然后每个页里面会放置很多个slab，而存储单元item就是放入这些slab中，主要的源码文件在slabs.c和item.c。可以先看看slabclass的数据结构：

typedef struct { unsigned int size; /* sizes of items */ unsigned int perslab; /* how many items per slab */ void **slots; /* list of item ptrs */ unsigned int sl_total; /* size of previous array */ unsigned int sl_curr; /* first free slot */ void *end_page_ptr; /* pointer to next free item at end of page, or 0 */ unsigned int end_page_free; /* number of items remaining at end of last alloced page */ unsigned int slabs; /* how many slabs were allocated for this class */ void **slab_list; /* array of slab pointers */ unsigned int list_size; /* size of prev array */ unsigned int killing; /* index+1 of dying slab, or zero if none */ size_t requested; /* The number of requested bytes */ } slabclass_t; 

 

slabclass主要用来描述slab的信息，每个slabclass里面有一个slablist的指针数组，用来记录当前已经分配的该大小的slab，还会有个slots的指针数组，用来记录存储的item的列表。

 

item的数据结构：

/** * Structure for storing items within memcached. */ typedef struct _stritem { struct _stritem *next; struct _stritem *prev; struct _stritem *h_next; /* hash chain next */ rel_time_t time; /* least recent access */ rel_time_t exptime; /* expire time */ int nbytes; /* size of data */ unsigned short refcount; uint8_t nsuffix; /* length of flags-and-length string */ uint8_t it_flags; /* ITEM_* above */ uint8_t slabs_clsid;/* which slab class we're in */ uint8_t nkey; /* key length, w/terminating null and padding */ /* this odd type prevents type-punning issues when we do * the little shuffle to save space when not using CAS. */ union { uint64_t cas; char end; } data[]; /* if it_flags & ITEM_CAS we have 8 bytes CAS */ /* then null-terminated key */ /* then " flags length/r/n" (no terminating null) */ /* then data with terminating /r/n (no terminating null; it's binary!) */ } item; 

很显然item是一个双向链表的节点，会包括自己的一个时间戳、过期时间以及数据。

 

那么内存是如何进行分配的呢？首先可以看看初始化时候的代码：

/** * Determines the chunk sizes and initializes the slab class descriptors * accordingly. */ void slabs_init(const size_t limit, const double factor, const bool prealloc) { int i = POWER_SMALLEST - 1; unsigned int size = sizeof(item) + settings.chunk_size; mem_limit = limit; if (prealloc) { /* Allocate everything in a big chunk with malloc */ mem_base = malloc(mem_limit); if (mem_base != NULL) { mem_current = mem_base; mem_avail = mem_limit; } else { fprintf(stderr, "Warning: Failed to allocate requested memory in" " one large chunk./nWill allocate in smaller chunks/n"); } } memset(slabclass, 0, sizeof(slabclass)); while (++i < POWER_LARGEST && size <= settings.item_size_max / factor) { /* Make sure items are always n-byte aligned */ if (size % CHUNK_ALIGN_BYTES) size += CHUNK_ALIGN_BYTES - (size % CHUNK_ALIGN_BYTES); slabclass[i].size = size; slabclass[i].perslab = settings.item_size_max / slabclass[i].size; size *= factor; if (settings.verbose > 1) { fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u/n", i, slabclass[i].size, slabclass[i].perslab); } } power_largest = i; slabclass[power_largest].size = settings.item_size_max; slabclass[power_largest].perslab = 1; if (settings.verbose > 1) { fprintf(stderr, "slab class %3d: chunk size %9u perslab %7u/n", i, slabclass[i].size, slabclass[i].perslab); } /* for the test suite: faking of how much we've already malloc'd */ { char *t_initial_malloc = getenv("T_MEMD_INITIAL_MALLOC"); if (t_initial_malloc) { mem_malloced = (size_t)atol(t_initial_malloc); } } #ifndef DONT_PREALLOC_SLABS { char *pre_alloc = getenv("T_MEMD_SLABS_ALLOC"); if (pre_alloc == NULL || atoi(pre_alloc) != 0) { slabs_preallocate(power_largest); } } #endif }  

如果没有设置prealloc的话，memcached会根据用户的配置：页大小、增长因子等等来初始化slabclass，这里只需初始化slabclass，至于如何分配一个slab，再看看这段代码：

static void *do_slabs_alloc(const size_t size, unsigned int id) { slabclass_t *p; void *ret = NULL; if (id < POWER_SMALLEST || id > power_largest) { MEMCACHED_SLABS_ALLOCATE_FAILED(size, 0); return NULL; } p = &slabclass[id]; assert(p->sl_curr == 0 || ((item *)p->slots[p->sl_curr - 1])->slabs_clsid == 0); #ifdef USE_SYSTEM_MALLOC if (mem_limit && mem_malloced + size > mem_limit) { MEMCACHED_SLABS_ALLOCATE_FAILED(size, id); return 0; } mem_malloced += size; ret = malloc(size); MEMCACHED_SLABS_ALLOCATE(size, id, 0, ret); return ret; #endif /* fail unless we have space at the end of a recently allocated page, we have something on our freelist, or we could allocate a new page */ if (! (p->end_page_ptr != 0 || p->sl_curr != 0 || do_slabs_newslab(id) != 0)) { /* We don't have more memory available */ ret = NULL; } else if (p->sl_curr != 0) { /* return off our freelist */ ret = p->slots[--p->sl_curr]; } else { /* if we recently allocated a whole page, return from that */ assert(p->end_page_ptr != NULL); ret = p->end_page_ptr; if (--p->end_page_free != 0) { p->end_page_ptr = ((caddr_t)p->end_page_ptr) + p->size; } else { p->end_page_ptr = 0; } } if (ret) { p->requested += size; MEMCACHED_SLABS_ALLOCATE(size, id, p->size, ret); } else { MEMCACHED_SLABS_ALLOCATE_FAILED(size, id); } return ret; } 

如果slots中的freelist中有空余内存或者当前页中还有空余内存，直接返回这块内存地址即可，否则就分配一个新的内存页。

 

对于一个set请求，会创建一个新的item，然后根据item的大小，找到一个最小的可以放下item的slab，然后将这个item放入这个slab里面，如果找不到这样的slab，则需要根据LRU策略回收掉一部分的内存。

 

散列管理：

assoc.c主要维护了两个散列表，当一个散列表的item个数超过一定范围后，会用一个线程在后台重建一个新的更大的散列表。主要的代码：

if (! expanding && hash_items > (hashsize(hashpower) * 3) / 2) { ||| maintenance_tid assoc_expand(); || } //当散列的item数目大于所能容纳数目的1.5倍后开始扩大 

扩大散列表的后台线程代码：

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. */ pthread_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, 0) & 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); if (settings.verbose > 1) fprintf(stderr, "Hash table expansion done/n"); } } if (!expanding) { /* We are done expanding.. just wait for next invocation */ pthread_cond_wait(&maintenance_cond, &cache_lock); } pthread_mutex_unlock(&cache_lock); } return NULL; } 

主要就是将旧的散列表中的item通过新的散列mask重新散列后放入新的散列表中。这种做法是为了保证开散列过程中，一个散列值的链表长度不至于太长，否则会影响性能。

 

总结：

给我印象最为深刻的还是内存管理及散列管理这块，体现了一定的数据结构和算法知识，实现的页非常漂亮。从读代码中还发现了很多自己以前不了解的东西，比如页大小可以设置成很大，但是官方推荐不要超过1M，否则性能会很差。