memcached学习笔记——存储命令源码分析上篇
原创文章，转载请标明，谢谢。
上一篇分析过memcached的连接模型，了解memcached是如何高效处理客户端连接，这一篇分析memcached源码中的process_update_command函数，探究memcached客户端的set命令，解读memcached是如何解析客户端文本命令，剖析memcached的内存管理，LRU算法是如何工作等等。
解析客户端文本命令
客户端向memcached server发出set操作，memcached server读取客户端的命令，客户端的连接状态由 conn_read > conn_parse_cmd 转换，这时候，memcached server开始解析命令。memcached server调用try_read_command函数解析命令，memcached接收两种格式的命令，一种是二进制格式，另一种是文本格式（本文只讲文本格式的命令）。
1 static int try_read_command(conn *c) { 2 3 // .......... 4 5 if (c->protocol == binary_prot) { 6 7 // 二进制格式 8 // .... 9 10 } else { 11 char *el, *cont; 12 13 // 没有接收到客户端的命令，返回进入conn_waiting状态，等待更多的客户端数据 14 if (c->rbytes == 0) 15 return 0; 16 17 el = memchr(c->rcurr, '\n', c->rbytes); 18 if (!el) { 19 if (c->rbytes > 1024) { 20 /* 21 * We didn't have a '\n' in the first k. This _has_ to be a 22 * large multiget, if not we should just nuke the connection. 23 */ 24 char *ptr = c->rcurr; 25 while (*ptr == ' ') { /* ignore leading whitespaces */ 26 ++ptr; 27 } 28 29 if (ptr - c->rcurr > 100 || 30 (strncmp(ptr, "get ", 4) && strncmp(ptr, "gets ", 5))) { 31 32 conn_set_state(c, conn_closing); 33 return 1; 34 } 35 } 36 37 return 0; 38 } 39 40 // 客户端报文以'\r\n'结尾 41 cont = el + 1; 42 if ((el - c->rcurr) > 1 && *(el - 1) == '\r') { 43 el--; 44 } 45 *el = '\0'; 46 47 assert(cont <= (c->rcurr + c->rbytes)); 48 49 // 真正解析命令的地方 50 process_command(c, c->rcurr); 51 52 c->rbytes -= (cont - c->rcurr); 53 c->rcurr = cont; 54 55 assert(c->rcurr <= (c->rbuf + c->rsize)); 56 } 57 58 return 1; 59 }
在分析process_command函数前，我们先看看memcached的命令格式：
1 <command name> <key> <flags> <exptime> <bytes> [noreply]\r\n 2 3 cas <key> <flags> <exptime> <bytes> <cas unique> [noreply]\r\n 4 5 // 例如 set 命令 ： 6 set key 0 60 2 7 12 8 STORED 9 10 // 空格对应着空格 11 set => <command name> 12 key => <key> 13 0 => <flags> 14 60 => <exptime> 15 2 => <bytes>
memcached在process_command中调用tokenize_command函数根据上面的命令格式处理命令，把相应位置的字段保存在 token_t *tokens 的相应位置。
1 // 参数1：命令的字符串 2 // 参数2：解析命令后，存放命令各个字段的结构体数组 3 // 参数3：命令字段的最大数量 4 /* 5 * tokens[0] => <command name> 的信息 6 * tokens[1] => <key> 的信息 7 * tokens[2] => <flags> 的信息 8 */ 9 static size_t tokenize_command(char *command, token_t *tokens, const size_t max_tokens) { 10 char *s, *e; 11 size_t ntokens = 0; 12 size_t len = strlen(command); 13 unsigned int i = 0; 14 15 assert(command != NULL && tokens != NULL && max_tokens > 1); 16 17 s = e = command; 18 for (i = 0; i < len; i++) { 19 if (*e == ' ') { 20 if (s != e) { 21 tokens[ntokens].value = s; // value存放各个字段的字符串值，例如：'set' 22 tokens[ntokens].length = e - s; // length表示各个字段相应的长度，例如：'set'的长度为3 23 ntokens++; 24 *e = '\0'; 25 if (ntokens == max_tokens - 1) { 26 e++; 27 s = e; /* so we don't add an extra token */ 28 break; 29 } 30 } 31 s = e + 1; 32 } 33 e++; 34 } 35 36 if (s != e) { 37 tokens[ntokens].value = s; 38 tokens[ntokens].length = e - s; 39 ntokens++; 40 } 41 42 /* 43 * If we scanned the whole string, the terminal value pointer is null, 44 * otherwise it is the first unprocessed character. 45 */ 46 tokens[ntokens].value = *e == '\0' ? NULL : e; 47 tokens[ntokens].length = 0; 48 ntokens++; 49 50 return ntokens; 51 }
解析完文本命令后，回到process_command函数中，我们可以看到很熟悉的命令，是的，接下来，在一个if-else的多分支判断中，memcached根据tokens[COMMAND_TOKEN].value决定调用那一个函数处理相应的命令：
1 static void process_command(conn *c, char *command) { 2 3 // .... 4 5 ntokens = tokenize_command(command, tokens, MAX_TOKENS); 6 if (ntokens >= 3 && 7 ((strcmp(tokens[COMMAND_TOKEN].value, "get") == 0) || 8 (strcmp(tokens[COMMAND_TOKEN].value, "bget") == 0))) { 9 10 // 这里就是执行get命令的分支 11 process_get_command(c, tokens, ntokens, false); 12 13 } else if ((ntokens == 6 || ntokens == 7) && 14 ((strcmp(tokens[COMMAND_TOKEN].value, "add") == 0 && (comm = NREAD_ADD)) || 15 (strcmp(tokens[COMMAND_TOKEN].value, "set") == 0 && (comm = NREAD_SET)) || 16 (strcmp(tokens[COMMAND_TOKEN].value, "replace") == 0 && (comm = NREAD_REPLACE)) || 17 (strcmp(tokens[COMMAND_TOKEN].value, "prepend") == 0 && (comm = NREAD_PREPEND)) || 18 (strcmp(tokens[COMMAND_TOKEN].value, "append") == 0 && (comm = NREAD_APPEND)) )) { 19 20 // 这里就是执行set、add、replace等命令的分支 21 process_update_command(c, tokens, ntokens, comm, false); 22 23 } else if ((ntokens == 7 || ntokens == 8) && (strcmp(tokens[COMMAND_TOKEN].value, "cas") == 0 && (comm = NREAD_CAS))) { 24 25 // 这里也执行process_update_command函数，也是对相应的key执行写操作，与上面一个分支不同的是最后一个参数是true，意思是写的过程使用CAS协议，这里不侧重讲， 26 // CAS目的是保证在并发写的时候保证一致性 27 process_update_command(c, tokens, ntokens, comm, true); 28 29 } else if .............
memcached存储命令分析
memcached把内存分割成各种尺寸的块（chunk），并把尺寸相同的块分成组（chunk的集合），每个chunk集合被称为slab。Memcached的内存分配以Page为单位，Page默认值为1M，可以在启动时通过-I参数来指定。Slab是由多个Page组成的，Page按照指定大小切割成多个chunk。
每一对[key,value]的数据被封装到item的结构体里，每种类型的slab用一个item链表来维护它的所有item。例如，一个item项的数据大小加上item的头部信息（为了方便描述，下面把这两项的和统称[key,value]大小吧）是90KB，slab[i]的chunk块大小是136KB，slab[i-1]的chunk块大小是88KB，那么item会被分配slab[i]的一个chunk块（并保存到slab[i]维护的一个item链表），这样做的目的是为了尽量减少内存碎片。更多关于Slab Allocation的原理可以查找其他的资料。这里不详解
memcached的存储命令：add、set、replace、append、prepend等，上面简单地说了memcached slab机制，知道memcached是根据相应的[key,value]大小找到相应的slab，那么，我们再次调用set命令某个已存在的key的value的时候，memcached是怎么工作的呢？
起初，我的直觉思维是，找到key相应的item，修改item的value就好了。那么，问题来了，假如先前[key,value]大小是90KB，被分配到slab[i]的，现在我们修改了key对应的value，[key,value]大小也改变了，变成了80KB，应该分配到slab[i-1]的，如果只是修改原来item的数据，那么就不符合Slab Allocation的原理，会造成很大的内存碎片浪费。
memcached对存储命令：add、set、replace、append、prepend处理方法大体都相似的，从上面的源码可以看出，都是通过执行process_update_command函数来处理。
memcached的处理存储命令思路是这样的：例如，客户端的一个set命令，memcached都会重新根据[key,value]大小找到合适slab，并把相应的数据封装到新的item里面【源码的注1】（不会直接修改旧的item项），如果对应的slab没有内存空间不足，就调用LRU算法把该slab的一个最近最少使用项的空间分配给新的item【源码的注2，出现在do_item_alloc函数】（如果关闭LRU移除项的功能，那么就会报“SERVER_ERROR out of memory storing object”错误，是set命令的话，还会把key对应的旧的item项移除【源码的注3】，即我们这时候不能通过get key来获取到旧的数据了），分配空间成功，那就是对add、set、replace、append、prepend这几个存储命令做差异化处理。
1 static void process_update_command(conn *c, token_t *tokens, const size_t ntokens, int comm, bool handle_cas) { 2 3 // .... 4 5 set_noreply_maybe(c, tokens, ntokens); // 设置命令可选字段的[noreply] 6 7 if (tokens[KEY_TOKEN].length > KEY_MAX_LENGTH) { 8 out_string(c, "CLIENT_ERROR bad command line format"); 9 return; 10 } 11 12 key = tokens[KEY_TOKEN].value; 13 nkey = tokens[KEY_TOKEN].length; 14 15 // 把命令相应字段的字符串安全转换成整数 16 if (! (safe_strtoul(tokens[2].value, (uint32_t *)&flags) 17 && safe_strtol(tokens[3].value, &exptime_int) 18 && safe_strtol(tokens[4].value, (int32_t *)&vlen))) { 19 out_string(c, "CLIENT_ERROR bad command line format"); 20 return; 21 } 22 23 exptime = exptime_int; 24 25 // #define REALTIME_MAXDELTA 60*60*24*30 26 if (exptime < 0) 27 exptime = REALTIME_MAXDELTA + 1; 28 29 // CAS协议，防止并发写不一致 30 if (handle_cas) { 31 if (!safe_strtoull(tokens[5].value, &req_cas_id)) { 32 out_string(c, "CLIENT_ERROR bad command line format"); 33 return; 34 } 35 } 36 37 // ........ 38 39 // 注1：无论是add、set或者是replace命令，都会从新分配一个新的item 40 it = item_alloc(key, nkey, flags, realtime(exptime), vlen); 41 42 // 如果新的item分配失败 43 if (it == 0) { 44 if (! item_size_ok(nkey, flags, vlen)) 45 out_string(c, "SERVER_ERROR object too large for cache"); // 一种错误情况：数据太大，没有合适slab，不能缓存数据 46 else 47 out_string(c, "SERVER_ERROR out of memory storing object"); // 另一种是：没有了内存空间缓存数据，通常这种事在关闭LRU功能的情况下出现 48 /* swallow the data line */ 49 c->write_and_go = conn_swallow; 50 c->sbytes = vlen; 51 52 // 注3：新的item分配失败，如果是set命令，并且key对应着存在旧的item，那么就把旧的item删除 53 if (comm == NREAD_SET) { 54 it = item_get(key, nkey); 55 if (it) { 56 item_unlink(it); 57 item_remove(it); 58 } 59 } 60 61 return; 62 } 63 ITEM_set_cas(it, req_cas_id); 64 65 c->item = it; 66 c->ritem = ITEM_data(it); 67 c->rlbytes = it->nbytes; 68 c->cmd = comm; 69 70 // 会在这一步进行add、set、replace等存储命令的差异化处理 71 conn_set_state(c, conn_nread); 72 }
do_item_alloc函数：
1 item *do_item_alloc(char *key, const size_t nkey, const int flags, 2 const rel_time_t exptime, const int nbytes, 3 const uint32_t cur_hv) { 4 uint8_t nsuffix; 5 item *it = NULL; 6 char suffix[40]; 7 size_t ntotal = item_make_header(nkey + 1, flags, nbytes, suffix, &nsuffix); //接收到的item数据长度+item头部长度 8 if (settings.use_cas) { 9 ntotal += sizeof(uint64_t); 10 } 11 12 unsigned int id = slabs_clsid(ntotal); 13 if (id == 0) 14 return 0; 15 16 mutex_lock(&cache_lock); 17 /* do a quick check if we have any expired items in the tail.. */ 18 int tries = 5; 19 int tried_alloc = 0; 20 item *search; 21 void *hold_lock = NULL; 22 rel_time_t oldest_live = settings.oldest_live; 23 24 search = tails[id]; 25 26 // tries = 5 ，循环查找过期的item，最多循环5次 27 for (; tries > 0 && search != NULL; tries--, search=search->prev) { 28 uint32_t hv = hash(ITEM_key(search), search->nkey, 0); 29 30 // 如果当前item被上锁，那么就跳过 31 if (hv != cur_hv && (hold_lock = item_trylock(hv)) == NULL) 32 continue; 33 /* Now see if the item is refcount locked */ 34 if (refcount_incr(&search->refcount) != 2) { 35 refcount_decr(&search->refcount); 36 /* Old rare bug could cause a refcount leak. We haven't seen 37 * it in years, but we leave this code in to prevent failures 38 * just in case */ 39 if (search->time + TAIL_REPAIR_TIME < current_time) { 40 itemstats[id].tailrepairs++; 41 search->refcount = 1; 42 do_item_unlink_nolock(search, hv); 43 } 44 if (hold_lock) 45 item_trylock_unlock(hold_lock); 46 continue; 47 } 48 49 // item过期，如果没有设置过期时间，那么就使用系统设置的默认过期时间 50 if ((search->exptime != 0 && search->exptime < current_time) 51 || (search->time <= oldest_live && oldest_live <= current_time)) { 52 itemstats[id].reclaimed++; 53 if ((search->it_flags & ITEM_FETCHED) == 0) { 54 itemstats[id].expired_unfetched++; 55 } 56 it = search; 57 slabs_adjust_mem_requested(it->slabs_clsid, ITEM_ntotal(it), ntotal); // 当前搜索的item过期，重新计算slab已经分配的字节 58 do_item_unlink_nolock(it, hv); // 把当前搜索的item从链表中移除 59 /* Initialize the item block: */ 60 it->slabs_clsid = 0; 61 } else if ((it = slabs_alloc(ntotal, id)) == NULL) { // 没有找到过期的item，新分配一个item，分配失败就执行else if里面的代码 62 tried_alloc = 1; 63 if (settings.evict_to_free == 0) { // 注2：内存耗尽，如果evict_to_free = 1（默认）LRU算法启动，移除最近最少使用的item 64 itemstats[id].outofmemory++; 65 } else { 66 itemstats[id].evicted++; 67 itemstats[id].evicted_time = current_time - search->time; 68 if (search->exptime != 0) 69 itemstats[id].evicted_nonzero++; 70 if ((search->it_flags & ITEM_FETCHED) == 0) { 71 itemstats[id].evicted_unfetched++; 72 } 73 it = search; 74 slabs_adjust_mem_requested(it->slabs_clsid, ITEM_ntotal(it), ntotal); // 当前搜索的item过期，重新计算slab已经分配的字节 75 do_item_unlink_nolock(it, hv); // 把当前需要移除的item从链表中移除 76 /* Initialize the item block: */ 77 it->slabs_clsid = 0; 78 79 if (settings.slab_automove == 2) 80 slabs_reassign(-1, id); 81 } 82 } 83 84 refcount_decr(&search->refcount); 85 /* If hash values were equal, we don't grab a second lock */ 86 if (hold_lock) 87 item_trylock_unlock(hold_lock); 88 break; 89 } 90 91 if (!tried_alloc && (tries == 0 || search == NULL)) 92 it = slabs_alloc(ntotal, id); 93 94 if (it == NULL) { 95 itemstats[id].outofmemory++; 96 mutex_unlock(&cache_lock); 97 return NULL; 98 } 99 100 assert(it->slabs_clsid == 0); 101 assert(it != heads[id]); 102 103 104 it->refcount = 1; 105 mutex_unlock(&cache_lock); 106 it->next = it->prev = it->h_next = 0; 107 it->slabs_clsid = id; 108 109 DEBUG_REFCNT(it, '*'); 110 it->it_flags = settings.use_cas ? ITEM_CAS : 0; 111 it->nkey = nkey; 112 it->nbytes = nbytes; 113 memcpy(ITEM_key(it), key, nkey); 114 it->exptime = exptime; 115 memcpy(ITEM_suffix(it), suffix, (size_t)nsuffix); 116 it->nsuffix = nsuffix; 117 return it; 118 }
以上memcached只是为[key,value]找到了新的slab，分配了新的item，并把命令相关的头部信息保存到，但是，还有一个重要的步奏没有说的，那就是[key,value]中的value怎么和item关联起来的，add和set的区别又是怎样区分的，由于还有很长的一段代码，所以我还是分篇记录，预告一下，下一篇《memcached学习笔记——存储命令源码分析下》会讲遗留的这两个问题。
未完，待续。
更多阅读查看：JC&hcoding
