Memcached源码阅读

Memcached源码阅读之服务器资源调整

本篇博客作为Memcached源码分析的开篇，这次阅读的源码版本为:1.4.15，开源软件各个版本之间差异比较大，同学们学习时，记得核对版本。

memcached的main函数位于memcached.c文件中，从main函数启动之后，会初始化一些资源和申请一些服务器资源，如下面所示：

1 Core文件大小和进程打开文件个数限制的调整。

 if (maxcore != 0)
 {
     struct rlimit rlim_new;
     //获取当前Core文件大小的配置值
     if (getrlimit(RLIMIT_CORE, &rlim) == 0)
     {
                 //变量初始化为无限制
                 rlim_new.rlim_cur = rlim_new.rlim_max = RLIM_INFINITY;
         if (setrlimit(RLIMIT_CORE, &rlim_new) != 0)//如果设置失败
         {
             //变量初始化为当前值的最大值
             rlim_new.rlim_cur = rlim_new.rlim_max = rlim.rlim_max;
             (void) setrlimit(RLIMIT_CORE, &rlim_new);//重新进行设置
         }
     }

         //再次确认Core文件允许的大小，如果当前的Core文件的大小为0，则不允许Core文件产生，和maxcore!=0不符，程序结束
     if ((getrlimit(RLIMIT_CORE, &rlim) != 0) || rlim.rlim_cur == 0)
     {
         fprintf(stderr, "failed to ensure corefile creation\n");
         exit(EX_OSERR);
     }
 }
 //读取进程允许打开的文件数信息，读取失败，程序退出
 if (getrlimit(RLIMIT_NOFILE, &rlim) != 0)
 {
     fprintf(stderr, "failed to getrlimit number of files\n");
     exit(EX_OSERR);
 }
 else
 {       //按memcached启动时的指定的最大连接数进行设置
     rlim.rlim_cur = settings.maxconns;
     rlim.rlim_max = settings.maxconns;
     if (setrlimit(RLIMIT_NOFILE, &rlim) != 0)
     {
         fprintf(stderr,
                 "failed to set rlimit for open files. Try starting as root or requesting smaller maxconns value.\n");
         exit(EX_OSERR);
     }
 }

2 启动用户的选择。

 //uid==0表示以root运行程序
 if (getuid() == 0 || geteuid() == 0)
 {       //以root运行程序，同时未指定新的用户名称
         if (username == 0 || *username == '\0')
     {
         fprintf(stderr, "can't run as root without the -u switch\n");
         exit(EX_USAGE);
     }
         //判断是否存在指定的用户名称
         if ((pw = getpwnam(username)) == 0)
     {
         fprintf(stderr, "can't find the user %s to switch to\n", username);
         exit(EX_NOUSER);
     }
         //按新的用户修改memcached的执行权限位
         if (setgid(pw->pw_gid) < 0 || setuid(pw->pw_uid) < 0)
     {
         fprintf(stderr, "failed to assume identity of user %s\n", username);
         exit(EX_OSERR);
     }
 }

3 以daemon的方式启动，daemon的实现如下，该daemon没有进行2次fork，APUE上面也有说第二次fork不是必须的。

 int daemonize(int nochdir, int noclose)
 {
     int fd;
     //首先fork一次
     switch (fork()) {
     case -1://fork失败，程序结束
         return (-1);
     case 0://子进程执行下面的流程
         break;
     default://父进程安全退出
         _exit(EXIT_SUCCESS);
     }
     //setsid调用成功之后，返回新的会话的ID，调用setsid函数的进程成为新的会话的领头进程，并与其父进程的会话组和进程组脱离
     if (setsid() == -1)
         return (-1);

     if (nochdir == 0) {
         //进程的当前目录切换到根目录下，根目录是一直存在的，其他的目录就不保证
         if(chdir("/") != 0) {
             perror("chdir");
             return (-1);
         }
     }

     if (noclose == 0 && (fd = open("/dev/null", O_RDWR, 0)) != -1) {
         if(dup2(fd, STDIN_FILENO) < 0) {//将标准输入重定向到/dev/null下
             perror("dup2 stdin");
             return (-1);
         }
         if(dup2(fd, STDOUT_FILENO) < 0) {//将标准输出重定向到/dev/null下
             perror("dup2 stdout");
             return (-1);
         }
         if(dup2(fd, STDERR_FILENO) < 0) {//将标准错误重定向到/dev/null下
             perror("dup2 stderr");
             return (-1);
         }

         if (fd > STDERR_FILENO) {
             if(close(fd) < 0) {//大于2的描述符都可以关闭
                 perror("close");
                 return (-1);
             }
         }
     }
     return (0);
 }

4 锁定内存，默认分配的内存都是虚拟内存，在程序执行过程中可以按需换出，如果内存充足的话，可以锁定内存，不让系统将该进程所持有的内存换出。

 if (lock_memory)
 {
 #ifdef HAVE_MLOCKALL
     int res = mlockall(MCL_CURRENT | MCL_FUTURE);
     if (res != 0)
     {
         fprintf(stderr, "warning: -k invalid, mlockall() failed: %s\n",
                 strerror(errno));
     }
 #else
     fprintf(stderr,
             "warning: -k invalid, mlockall() not supported on this platform.  proceeding without.\n");
 #endif
 }

5 忽略PIPE信号，PIPE信号是当网络连接一端已经断开，这时发送数据，会进行RST的重定向，再次发送数据，会触发PIPE信号，而PIPE信号的默认动作是退出进程，所以需要忽略该信号。

 if (sigignore(SIGPIPE) == -1)
 {
     perror("failed to ignore SIGPIPE; sigaction");
     exit(EX_OSERR);
 }

6 保存daemon进程的进程id到文件中，这样便于控制程序，读取文件内容，即可得到进程ID。 

 if (pid_file != NULL)
 {
     save_pid(pid_file);
 }

Memcached源码阅读之初始化参数解析

Memcached启动时，有很多配置参数可以选择，这些配置参数严重影响着Memcached的使用，下面分析下这些参数的意义，开源软件版本之间差异比较大，我这次分析是基于1.4.15进行分析的，大家学习时记得核对版本。

 "a:" //unix socket的权限位信息，unix socket的权限位信息和普通文件的权限位信息一样
 "p:" //memcached监听的TCP端口值，默认是11211
 "s:" //unix socket监听的socket文件路径
 "U:" //memcached监听的UDP端口值，默认是11211
 "m:" //memcached使用的最大内存值，默认是64M
 "M"  //当memcached的内存使用完时，不进行LRU淘汰数据，直接返回错误，该选项就是关闭LRU
 "c:" //memcached的最大连接数,如果不指定，按系统的最大值进行
 "k"  //是否锁定memcached所持有的内存，如果锁定了内存，其他业务持有的内存就会减小
 "hi" //帮助信息
 "r"  //core文件的大小，如果不指定，按系统的最大值进行
 "v"  //调试信息
 "d"  //设定以daemon方式运行
 "l:" //绑定的ip信息，如果服务器有多个ip，可以在多个ip上面启动多个Memcached实例，注意：这个不是可接收的IP地址
 "u:" //memcached运行的用户，如果以root启动，需要指定用户，否则程序错误，退出。
 "P:" //memcached以daemon方式运行时，保存pid的文件路径信息
 "f:" //内存的扩容因子，这个关系到Memcached内部初始化空间时的一个变化，后面详细说明
 "n:" //chunk的最小大小(byte)，后续的增长都是该值*factor来进行增长的
 "t:" //内部worker线程的个数，默认是4个，最大值推荐不超过64个
 "D:" //内部数据存储时的分割符
 "L"  //指定内存页的大小，默认内存页大小为4K，页最大不超过2M，调大页的大小，可有效减小页表的大小,提高内存访问的效率
 "R:" //单个worker的最大请求个数
 "C"  //禁用业务的cas,即compare and set
 "b:" //listen操作缓存连接个数
 "B:" //memcached内部使用的协议，支持二进制协议和文本协议，早期只有文本协议，二进制协议是后续加上的
 "I:" //单个item的最大值，默认是1M,可以修改，修改的最小值为1k,最大值不能超过128M
 "S"  //打开sasl安全协议
 "o:" //有四个参数项可以设置:
  maxconns_fast(如果连接数超过最大连接数，立即关闭新的连接)
  hashpower(hash表的大小的指数值，是按1<<hashpower来创建hash表的，默认的hashpower为16，配置值建议不超过64)
  slab_reassign（是否调整/平衡各个slab所占的内存）
  slab_automove（是否自动移动各个slab，如果该选项打开，会有专门的线程来进行slab的调整）

Memcached内部是通过settings来抽象上面的这些初始化参数。

 struct settings {
     size_t maxbytes;
     int maxconns;
     int port;
     int udpport;
     char *inter;
     int verbose;
     rel_time_t oldest_live; /* ignore existing items older than this */
     int evict_to_free;
     char *socketpath;   /* path to unix socket if using local socket */
     int access;  /* access mask (a la chmod) for unix domain socket */
     double factor;          /* chunk size growth factor */
     int chunk_size;
     int num_threads;        /* number of worker (without dispatcher) libevent threads to run */
     int num_threads_per_udp; /* number of worker threads serving each udp socket */
     char prefix_delimiter;  /* character that marks a key prefix (for stats) */
     int detail_enabled;     /* nonzero if we're collecting detailed stats */
     int reqs_per_event;     /* Maximum number of io to process on each
                                io-event. */
     bool use_cas;
     enum protocol binding_protocol;
     int backlog;
     int item_size_max;        /* Maximum item size, and upper end for slabs */
     bool sasl;              /* SASL on/off */
     bool maxconns_fast;     /* Whether or not to early close connections */
     bool slab_reassign;     /* Whether or not slab reassignment is allowed */
     int slab_automove;     /* Whether or not to automatically move slabs */
     int hashpower_init;     /* Starting hash power level */
 };

改结构的初始化：

 static void settings_init(void)
 {
     settings.use_cas = true;
     settings.access = 0700;
     settings.port = 11211;
     settings.udpport = 11211;
     /* By default this string should be NULL for getaddrinfo() */
     settings.inter = NULL;
     settings.maxbytes = 64 * 1024 * 1024; /* default is 64MB */
     settings.maxconns = 1024; /* to limit connections-related memory to about 5MB */
     settings.verbose = 0;
     settings.oldest_live = 0;
     settings.evict_to_free = 1; /* push old items out of cache when memory runs out */
     settings.socketpath = NULL; /* by default, not using a unix socket */
     settings.factor = 1.25;
     settings.chunk_size = 48; /* space for a modest key and value */
     settings.num_threads = 4; /* N workers */
     settings.num_threads_per_udp = 0;
     settings.prefix_delimiter = ':';
     settings.detail_enabled = 0;
     settings.reqs_per_event = 20;
     settings.backlog = 1024;
     settings.binding_protocol = negotiating_prot;
     settings.item_size_max = 1024 * 1024; /* The famous 1MB upper limit. */
     settings.maxconns_fast = false;
     settings.hashpower_init = 0;
     settings.slab_reassign = false;
     settings.slab_automove = 0;
 }

这些值都是一些默认值，后续按启动时所指定的进行修改，比如对监听端口号的修改：

         case 'a'://修改unix socket的权限位信息
         settings.access = strtol(optarg, NULL, 8);
         break;
     case 'U'://udp端口信息
         settings.udpport = atoi(optarg);
         udp_specified = true;
         break;
     case 'p'://tcp端口信息
         settings.port = atoi(optarg);
         tcp_specified = true;
         break;

Memcached源码阅读之资源初始化

Memcached内部有hash表，各种统计信息，工作线程，网络，连接，内存结构等，在memcached启动时(执行main函数)，会对这些资源进行初始化的，网络和内存的初始化操作放到后续分析，这次分析hash表，统计信息，工作线程，网络连接的初始化过程。

1 hash表的初始化 

 //hash表的初始化，传入的参数是启动时传入的
 assoc_init(settings.hashpower_init);
 //hashsize的实现
 #define hashsize(n) ((ub4)1<<(n))
 //主hash表结构定义，在hash表扩容时，会有次hash表，所以有主次hash表区分，该结构是指针的指针，也即相当于数组指针
 static item** primary_hashtable = 0;

 void assoc_init(const int hashtable_init) {
     if (hashtable_init) {//如果设置了初始化参数，则按设置的参数进行初始化
         hashpower = hashtable_init;
     }
     //hashpower的默认值为16,如果未设置新值，则按默认值进行初始化
     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();
 }

2 统计信息的初始化

Memcached内部有很多全局的统计信息，用于实时获取各个资源的使用情况，后面将会看到，所有对统计信息的更新都需要加锁，而这些信息的更新是和Memcached的操作次数同数量级的，所以，在一定程度来说，这些统计信息对性能有影响。

stats结构是对统计信息的一个抽象，各个字段都比较好理解，不做解释。

 struct stats {
     pthread_mutex_t mutex;
     unsigned int  curr_items;
     unsigned int  total_items;
     uint64_t      curr_bytes;
     unsigned int  curr_conns;
     unsigned int  total_conns;
     uint64_t      rejected_conns;
     unsigned int  reserved_fds;
     unsigned int  conn_structs;
     uint64_t      get_cmds;
     uint64_t      set_cmds;
     uint64_t      touch_cmds;
     uint64_t      get_hits;
     uint64_t      get_misses;
     uint64_t      touch_hits;
     uint64_t      touch_misses;
     uint64_t      evictions;
     uint64_t      reclaimed;
     time_t        started;          /* when the process was started */
     bool          accepting_conns;  /* whether we are currently accepting */
     uint64_t      listen_disabled_num;
     unsigned int  hash_power_level; /* Better hope it's not over 9000 */
     uint64_t      hash_bytes;       /* size used for hash tables */
     bool          hash_is_expanding; /* If the hash table is being expanded */
     uint64_t      expired_unfetched; /* items reclaimed but never touched */
     uint64_t      evicted_unfetched; /* items evicted but never touched */
     bool          slab_reassign_running; /* slab reassign in progress */
     uint64_t      slabs_moved;       /* times slabs were moved around */
 };

统计信息的初始化也就是对stats变量的一个初始化。

 //全局对象的定义
 struct stats stats;
 //全局变量的初始化，该全局变量在memcached启动之后，一直使用
 static void stats_init(void)
 {
     stats.curr_items = stats.total_items = stats.curr_conns =
             stats.total_conns = stats.conn_structs = 0;
     stats.get_cmds = stats.set_cmds = stats.get_hits = stats.get_misses =
             stats.evictions = stats.reclaimed = 0;
     stats.touch_cmds = stats.touch_misses = stats.touch_hits =
             stats.rejected_conns = 0;
     stats.curr_bytes = stats.listen_disabled_num = 0;
     stats.hash_power_level = stats.hash_bytes = stats.hash_is_expanding = 0;
     stats.expired_unfetched = stats.evicted_unfetched = 0;
     stats.slabs_moved = 0;
     stats.accepting_conns = true; /* assuming we start in this state. */
     stats.slab_reassign_running = false;

     /* make the time we started always be 2 seconds before we really
      did, so time(0) - time.started is never zero.  if so, things
      like 'settings.oldest_live' which act as booleans as well as
      values are now false in boolean context... */
     process_started = time(0) - 2;
     stats_prefix_init();
 }

3 工作线程的初始化

Memcached采用了典型的Master-Worker的线程模式，Master就是由main线程来充当，而Worker线程则是通过Pthread创建的。

 //传入线程个数和libevent的main_base实例
 thread_init(settings.num_threads, main_base);

 //工作线程初始化
 void thread_init(int nthreads, struct event_base *main_base) {
     int         i;
     int         power;
     //初始化各种锁和条件变量
     pthread_mutex_init(&cache_lock, NULL);
     pthread_mutex_init(&stats_lock, NULL);

     pthread_mutex_init(&init_lock, NULL);
     pthread_cond_init(&init_cond, NULL);

     pthread_mutex_init(&cqi_freelist_lock, NULL);
     cqi_freelist = NULL;

     //Memcached对hash桶的锁采用分段锁，按线程个数来分段，默认总共是1<<16个hash桶，而锁的数目是1<<power个
     /* Want a wide lock table, but don't waste memory */
     if (nthreads < 3) {
         power = 10;
     } else if (nthreads < 4) {
         power = 11;
     } else if (nthreads < 5) {
         power = 12;
     } else {
         /* 8192 buckets, and central locks don't scale much past 5 threads */
         power = 13;
     }

     item_lock_count = hashsize(power);
     //申请1<<power个pthread_mutex_t锁，保存在item_locks数组。
     item_locks = calloc(item_lock_count, sizeof(pthread_mutex_t));
     if (! item_locks) {
         perror("Can't allocate item locks");
         exit(1);
     }
     //对这些锁进行初始化，这部分可参考APUE的线程部分
     for (i = 0; i < item_lock_count; i++) {
         pthread_mutex_init(&item_locks[i], NULL);
     }
     /*创建线程的局部变量，该局部变量的名称为item_lock_type_key,用于保存主hash表所持有的锁的类型
     主hash表在进行扩容时，该锁类型会变为全局的锁，否则(不在扩容过程中)，则是局部锁*/
     pthread_key_create(&item_lock_type_key, NULL);
     pthread_mutex_init(&item_global_lock, NULL);
     //申请nthreds个工作线程,LIBEVENT_THREAD是Memcached内部对工作线程的一个封装
     threads = calloc(nthreads, sizeof(LIBEVENT_THREAD));
     if (! threads) {
         perror("Can't allocate thread descriptors");
         exit(1);
     }
     /*分发线程的初始化,分发线程的base为main_base
     线程id为main线程的线程id*/
     dispatcher_thread.base = main_base;
     dispatcher_thread.thread_id = pthread_self();
     //工作线程的初始化,工作线程和主线程(main线程)是通过pipe管道进行通信的
     for (i = 0; i < nthreads; i++) {
         int fds[2];
         if (pipe(fds)) {//初始化pipe管道
             perror("Can't create notify pipe");
             exit(1);
         }

         threads[i].notify_receive_fd = fds[0];//读管道绑定到工作线程的接收消息的描述符
         threads[i].notify_send_fd = fds[1];//写管道绑定到工作线程的发送消息的描述符

         setup_thread(&threads[i]);//添加工作线程到libevent中
         /* Reserve three fds for the libevent base, and two for the pipe */
         stats.reserved_fds += 5;//统计信息更新
     }

     //创建工作线程
     for (i = 0; i < nthreads; i++) {
         create_worker(worker_libevent, &threads[i]);
     }

     //等待所有工作线程创建完毕
     pthread_mutex_lock(&init_lock);
     wait_for_thread_registration(nthreads);
     pthread_mutex_unlock(&init_lock);
 }
 //Memcached内部工作线程的封装
 typedef struct {
     pthread_t thread_id;       //线程ID
     struct event_base *base;   //libevent的不是线程安全的，每个工作线程持有一个libevent实例，用于pipe管道通信和socket通信
     struct event notify_event; //用于监听pipe管道的libevent事件
     int notify_receive_fd;      //接收pipe管道消息描述符
     int notify_send_fd;         //发送pipe管道消息描述符
     struct thread_stats stats;  //每个线程对应的统计信息
     struct conn_queue *new_conn_queue; //每个线程都有一个工作队列，主线程接受的连接，挂载到该消息队列中
     cache_t *suffix_cache;      //后缀cache
     uint8_t item_lock_type;     //线程操作hash表持有的锁类型，有局部锁和全局锁
 } LIBEVENT_THREAD;

 //分发线程的封装
 typedef struct {
     pthread_t thread_id;        //线程id
     struct event_base *base;    //libevent实例
 } LIBEVENT_DISPATCHER_THREAD;

 //工作线程绑定到libevent实例
 static void setup_thread(LIBEVENT_THREAD *me) {
     me->base = event_init();//创建libevent实例
     if (! me->base) {
         fprintf(stderr, "Can't allocate event base\n");
         exit(1);
     }

     //创建管道读的libevent事件，事件的回调函数处理具体的业务信息，关于回调函数的处理，后续分析
     event_set(&me->notify_event, me->notify_receive_fd,
               EV_READ | EV_PERSIST, thread_libevent_process, me);
     event_base_set(me->base, &me->notify_event);//设置libevent实例
     //添加事件到libevent中
     if (event_add(&me->notify_event, 0) == -1) {
         fprintf(stderr, "Can't monitor libevent notify pipe\n");
         exit(1);
     }
     //创建消息队列，用于接受主线程连接
     me->new_conn_queue = malloc(sizeof(struct conn_queue));
     if (me->new_conn_queue == NULL) {
         perror("Failed to allocate memory for connection queue");
         exit(EXIT_FAILURE);
     }
     cq_init(me->new_conn_queue);//消息队列初始化

     if (pthread_mutex_init(&me->stats.mutex, NULL) != 0) {
         perror("Failed to initialize mutex");
         exit(EXIT_FAILURE);
     }
     //创建线程的后缀cache,没搞懂这个cache有什么作用。
     me->suffix_cache = cache_create("suffix", SUFFIX_SIZE, sizeof(char*),
                                     NULL, NULL);
     if (me->suffix_cache == NULL) {
         fprintf(stderr, "Failed to create suffix cache\n");
         exit(EXIT_FAILURE);
     }
 }

 //创建工作线程
 static void create_worker(void *(*func)(void *), void *arg) {
     pthread_t       thread;
     pthread_attr_t  attr;
     int             ret;

     pthread_attr_init(&attr);//Posix线程部分，线程属性初始化
     //通过pthread_create创建线程，线程处理函数是通过外部传入的处理函数为worker_libevent
     if ((ret = pthread_create(&thread, &attr, func, arg)) != 0) {
         fprintf(stderr, "Can't create thread: %s\n",
                 strerror(ret));
         exit(1);
     }
 }
 //线程处理函数
 static void *worker_libevent(void *arg) {
     LIBEVENT_THREAD *me = arg;
     //默认的hash表的锁为局部锁
     me->item_lock_type = ITEM_LOCK_GRANULAR;
     pthread_setspecific(item_lock_type_key, &me->item_lock_type);//设定线程的属性
     //用于控制工作线程初始化，通过条件变量来控制
     register_thread_initialized();
     //工作线程的libevent实例启动
     event_base_loop(me->base, 0);
     return NULL;
 }
 //阻塞工作线程
 static void wait_for_thread_registration(int nthreads) {
     while (init_count < nthreads) {
         pthread_cond_wait(&init_cond, &init_lock);//在条件变量init_cond上面阻塞，阻塞个数为nthreads-init_count
     }
 }
 //唤醒工作线程
 static void register_thread_initialized(void) {
     pthread_mutex_lock(&init_lock);
     init_count++;
     pthread_cond_signal(&init_cond);
     pthread_mutex_unlock(&init_lock);
 }

 //每个线程持有的统计信息
 struct thread_stats {
     pthread_mutex_t   mutex;
     uint64_t          get_cmds;
     uint64_t          get_misses;
     uint64_t          touch_cmds;
     uint64_t          touch_misses;
     uint64_t          delete_misses;
     uint64_t          incr_misses;
     uint64_t          decr_misses;
     uint64_t          cas_misses;
     uint64_t          bytes_read;
     uint64_t          bytes_written;
     uint64_t          flush_cmds;
     uint64_t          conn_yields; /* # of yields for connections (-R option)*/
     uint64_t          auth_cmds;
     uint64_t          auth_errors;
     struct slab_stats slab_stats[MAX_NUMBER_OF_SLAB_CLASSES];
 };
 //每个slab的统计信息
 struct slab_stats {
     uint64_t  set_cmds;
     uint64_t  get_hits;
     uint64_t  touch_hits;
     uint64_t  delete_hits;
     uint64_t  cas_hits;
     uint64_t  cas_badval;
     uint64_t  incr_hits;
     uint64_t  decr_hits;
 };

4 连接的初始化

 static conn **freeconns;//空闲连接列表
 //连接初始化
 static void conn_init(void)
 {
     freetotal = 200;//空闲连接总数
     freecurr = 0;//当前空闲的索引
         //申请200个空间
         if ((freeconns = calloc(freetotal, sizeof(conn *))) == NULL)
     {
         fprintf(stderr, "Failed to allocate connection structures\n");
     }
     return;
 }